---
title: "The Data Vault Template Language (DVT)"
canonical: "https://docs.vaultspeed.com/space/VPD/3011182712/The%20Data%20Vault%20Template%20Language%20(DVT)"
format: markdown
---
VaultSpeed uses a set of templates written in our own Data Vault Template Language (DVT).  
The VaultSpeed Templates are text files with the `.dvt` file extension.  
VaultSpeed compiles them into SQL code, groovy code, job script, etc.

> Macro (toc)

# 1. Language and structure

The DVT language has a hierarchical structure. Each level in the hierarchy starts with a specific keyword and continues until the next one or the end of the file. Each of these levels can be conditioned based on specific parameters and variables. This allows you to combine the logic for different types of objects into one template.

The language consists of the following levels:

- ** Mapping **(Overall level)
- ** Template **(highest level per template file)
- ** Component_group** (groups to define parts of a query, e.g. insert, update, select, inline_view, …)
- ** Component **(a component in the group, e.g. table, filter, join, union, ….)
- ** Attribute **(an attribute is a general Signature attribute)
- ** Expression **(an expression for this attribute)

![image](media://45ca4a8a-1023-43c5-ade8-36317e7ecc95)


# 2. Hierarchy

## Level 1: Mapping

The highest level in the language. A mapping is a .dvt file. In a mapping, you can have multiple actions. E.g. a truncate, a delete, an insert, an update, ….

Ultimately, it will be transformed into one Procedure/function/Job script file/Groovy file/view.

A mapping consists of a set of templates.  
example:

```
TEMPLATE trunc
  ...
TEMPLATE ins_temp
  ...
TEMPLATE ins
  ...
TEMPLATE upd
  ...
```

Limitations: 

- A view mapping can only have one template in it.
- DBT mappings can only contain one write action(insert/update/merge) per object. Truncates will end up in pre-hooks, and deletes will end up in a pre- or post-hook, depending on their location in the template.

SQL example:

```sql
Create or replace function SAT_CALC_INIT$FUNCTION$
-- template 1 
with hub_calc as (
  select 
         hub_src. invoices_hkey as invoices_hkey
  from dv_layer.hub_invoices  hub_src
  where hub_src.load_cycle_id not in (-1,-2)
)
insert into bv_layer.sat_ms_invoices_calc(invoices_hkey, sum_amount)select 
       sat_src.invoices_hkey as invoices_hkey,
       sum(sat_src.amount) as sum_amount
from dv_layer.sat_ms_invoices sat_src 
inner join dv_layer.hub_invoices hub_src on hub_src.invoices_hkey = sat_src.invoices_hkey
group by sat_src.invoices_hkey;

-- template 2 UPDATE
update bv_layer.sat_ms_invoices_calc(attr2)
set 
  valid_flag = false 
from dv_layer.sat_ms_invoices sat_src 
where sat_src.load_date > current_timestamp;

-- template 3 DELETE
delete from bv_layer.sat_ms_invoices_calc
where valid_flag = false;

$FUNCTION$
```

## Level 2: Template

A template is defined by the "template" keyword, followed by a name.

The purpose of a template is to do an action with a specific target table/view. In SQL, a template will be translated into a query.

 Each template can contain several component groups and may contain supergroups.

```
TEMPLATE DOLLAR? TEMPLATE_NAME? 
CONDITION_PARAMETER* 
(COMPONENT_SUPERGROUP|COMPONENT_GROUP)*
```

- **template: **A keyword to recognize the beginning of a template.
- **dollar($)** → A repeater symbol when used every element in the component_supergroup level and the levels below will be repeated. In the template, this is represented by a $-symbol.
- **template_name: **Name given to the template. (should be one word without spaces)
- **condition_parameter: **A condition branch structure to condition the template. Multiple conditions can be added. (see conditions chapter)
- **component_supergroup: **A level beneath the template. A template can contain multiple component_supergroups. (This is a combination of component groups)
- **component_group: **A level beneath the template. A template can contain multiple component groups.

Template example:

```
Template SAT_DFL_TGT
templateConditionedBy [(TAB SAT : HARD_DELETE = Y)]	
  comp_group_start ...
    ...
  comp_group_end
  
  comp_group_start ...
    ...
  comp_group_end
```

## Level 3: Component_supergroup / component_group / component_subgroup

The DVT language uses three kinds of component groups: the component_supergroup, the component_group, and the component_subgroup.

The purpose of a component group is to implement a specific table action, e.g. insert, update, merge, etc.

**A component_supergroup contains several component_groups.**

**A component_group contains a list of components and may contain a component_subgroup.**

**A component_subgroup contains a list of components.** 

### Level 3.1: Component_supergroup

A component_supergroup contains several component_groups. It was developed to loop through a combination of component_groups

```
COMP_SUPERGROUP_START DOLLAR? COMPONENT_GROUP_NAME 
  CONDITION_PARAMETER*
  COMPONENT_REPETITION_PARAMETER? 
  COMPONENT_GROUP* 
COMP_SUPERGROUP_END
```

- **comp_supergroup_start **→ A keyword to recognize the beginning of a component_supergroup.
- **dollar($)** → A repeater symbol when used every element in the component_supergroup level and the levels below will be repeated. In the template, this is represented by a $-symbol.
- **component_group_name **→ Name given to the component_supergroup. (free to choose, should be one word)
- **condition_parameter **→ A condition branch structure to condition the component_supergroup. Multiple conditions can be added.
- **component_repetition_parameter **→ Every component_supergroup can be repeated by a component in the database and will be added here if necessary to repeat. This is important if you e.g. want to loop through all sats, then you repeat by SAT
- **component_group **→  A level beneath component_supergroup. A component_supergroup can contain multiple component groups.
- **comp_supergroup_end **→ A keyword to recognize the end of a component_supergroup.

Example:

```
comp_supergroup_start $ SUPER_GROUP	
componentSuperGroupConditionedBy [(TAB EXT_FK$ : PK_SAME_AS_BK = N)]
RepeatedByObject EXT_FK
```

### Level 3.2: Component_group

 A component_group contains a list of components and may contain a component_subgroup.

```
COMP_GROUP_START DOLLAR? COMPONENT_GROUP_NAME COMPONENT_GROUP_TYPE 
  CONDITION_PARAMETER* 
  COMPONENT_REPETITION_PARAMETER? 
  COMPONENT_LIST COMPONENT_SUBGROUP* 
COMP_GROUP_END
```

- **comp_group_start **→ A keyword to recognize the beginning of a component_group.
- **dollar($) **→ A repeater symbol, when used, every element in the component_group level and below will be repeated.
- **component_group_name **→ The name of the component_group is used, for example, to give the component group a unique name.
- **component_group_type **→ The type of the component_group tells the difference between table actions (select, update, insert, merge, …) and the type (inline_view, main, …).
- **condition_parameter **→ A condition branch structure to condition the component_group. Multiple conditions can be added.
- **component_repetition_parameter **→ Every component_group can be repeated by a component in the database and will be added here if necessary to repeat.
- **component_list **→ A level beneath component_group.
- **component_subgroup **→ A level beneath component_group.
- **comp_group_end **→ A keyword to recognize the end of a component_group.

Example

```
comp_group_start TRUNCATE_GROUP TRUNC_GRP
RepeatedbyObject LAS_TEMP

comp_group_end
```

Types:

- **CREA_GRP**: The visitor knows the metadata inside will give the information needed for the creation or altering of a table
  - CREATE_TABLE: to create a table, give specific info ‘CREATE_TABLE’ and list the signature attributes you want to include in the DDL.
  - DROP_TABLE: to drop a table, give the specific info ‘DROP_TABLE’. No signature attributes are needed.

 

- **DEF_GRP**: When you want to use a property of a specific table but don’t want to use the table itself in the code, you can always define it.   
Contains a source table component.

 

- **DEL_GRP**: Delete from a table can contain a target table component, a source table component, and a possible filter.

 

- **EXISTS_GRP**: Adds an existing subquery.  
In the component_group before the exists_group, there should be a filter expressed by NOT EXISTS or EXISTS based on the action you want to trigger.

 

- **INL_V_GRP**: This allows for the definition of inline views. Depending on the SQL flavour, these will become CTEs or subqueries. These component groups can be sources for other component groups (see component documentation).

 

- **INS_GRP**: This component will generate the insert into a table and take care of the final selection needed for the insert.   
For views, this group defines the final selection (the insert statement is not created).  
This group should have at least a Target table component containing all the attributes you want to insert.

 

- **VIEW_GRP**: This component will generate the create view and final select.  
This group should have at least a Target table component containing all the attributes you want to insert.


- **MERGE_GRP**: This group defines a merge. It has some unique components which can be used to define the merge behaviour:
  - Merge on table component (Which attributes to merge on)
  - Merge matched table component (Which attributes to update when matched)
  - Merge not matched table component (Which attributes to insert when not matched)
  - A Merge always needs an inline view, as the previous group

 

- **SEL_GRP**: The select group defines a source object and its attributes. These are needed when generating Talend code for every object used in a source component.

 

- **TRUNC_GRP**: This group defines a truncate statement. It only requires a target component, which defines which table to truncate. This component can be added to templates that already contain insert components, it does not require a separate template.

 

- **UPD_GRP**: This group defines an update. It has two unique components which determine the behaviour.
  - Update set component (Which attributes to update)
  - Update condition component (filter to define which records get updated)
  - The update will always need an inline view, as in the previous group. It cannot use a regular table as a source.

 

### Level 3.3: Component_subgroup

A component_subgroup contains a list of components. This will be used if you want to loop through a collection of components.

```
COMP_SUBGROUP_START DOLLAR? COMPONENT_SUBGROUP_NAME 
  CONDITION_PARAMETER* 
  COMPONENT_REPETITION_PARAMETER? 
  COMPONENT_LIST 
COMP_SUBGROUP_END
```

- **comp_subgroup_start **→ A keyword to recognize the beginning of a component_subgroup.
- **dollar($) **→ A repeater symbol when used every element in the component_subgroup level and the level below will be repeated.
- **component_subgroup_name **→ The name of the component_subgroup is used, for example, to give the component group a unique name.
- **condition_parameter **→ A condition branch structure to condition the component_subgroup. Multiple conditions can be added.
- **component_repetition_parameter **→ Every component_subgroup can be repeated by a component in the database and will be added here if necessary to repeat.
- **component_list **→ A level beneath component_subgroup.
- **comp_subgroup_end **→ A keyword to recognize the end of a component_subgroup.

Example:

```
comp_subgroup_start $ JOIN_EXT_SRC_FIND_BK_FK_SUBGROUP
RepeatedByObject EXT_FK

		consists of left_outer join JOIN_EXT_SRC_FIND_BK_FK$
		componentConditionedBy [(TAB EXT_FK$ : PK_SAME_AS_BK = N)]
		RepeatedByObject EXT_FK$
		connectsFrom (JOIN_EXT_SRC_MEX_SRC)
					connectionConditionedBy [(LOOP: PK_NOT_SAME_AS_BK = 1)]
					 (JOIN_EXT_SRC_FIND_BK_FK$ PK_NOT_SAME_AS_BK PREV)
					connectionConditionedBy [(LOOP: PK_NOT_SAME_AS_BK > 1)]
		connectsFrom (FIND_BK_FK$)

					Artifact GENERAL_EXPRESSION
						GROUP_1 expressedBy  EXT_SRC.FOREIGN_KEY$ = FIND_BK_FK$.FOREIGN_KEY$
							expressionDefinedByAttribute EXT_SRC.FOREIGN_KEY$ AND

		consists of joined inline_view FIND_BK_FK$
		componentConditionedBy [(TAB EXT_FK$ : PK_SAME_AS_BK = N)]
		RepeatedByObject EXT_FK$

comp_subgroup_end
```

## Level 4: Component

The "consists of" keyword defines a component.

The purpose of a component is to specify the tables, filters, joins, etc., needed for the group action.

```
CONSISTS OF SPECIFIC_INFO? COMPONENT_TYPE_DESCR COMPONENT_TYPE_NAME 
CONDITION_PARAMETER* 
COMPONENT_REPETITION_PARAMETER?
```

- **consists of **→ A keyword group to recognize the beginning of a component.
- **specific_info**→ As many components are supported, specific information can be included here. When describing a table
- **component_type_descr **→ The type of component: table, filter, join, …
- **component_type_name **→ The alias given to this component to use in expressions. It can have a dollar at the end if you want to make the alias unique.
- **condition_parameter **→ To condition the component. Multiple conditions can be added.
- **component_repetition_parameter **→ Every component can be repeated by a certain object type.

Example

```
			consists of target inline_view FIND_BK_FK$
			RepeatedByObject EXT_FK$
			connectsFrom (JOIN_DIST_FK_EXT_FKBK_SRC$)
	
						Attribute BUSINESS_KEY
							expressedBy EXT_FKBK_SRC$.BUSINESS_KEY
							expressionDefinedByAttribute EXT_FKBK_SRC$.BUSINESS_KEY

						Attribute FOREIGN_KEY$
							expressedBy DIST_FK$.FOREIGN_KEY$
								expressionDefinedByAttribute FIND_BK_FK$.FOREIGN_KEY$
```

Component types and their specific info possibilities:

- **TABLE**: Table component to select from or do an action on a table
  - **SOURCE**: specific info keyword which will trigger ‘FROM'
  - ** TARGET**: specific info keyword which will trigger ‘INTO' (in combination with the INS_GRP)
  - **JOINED**: specific info keyword to tell the template interpreter this is the joined table in a join. Otherwise, a 'FROM' would appear twice, so always used after a join component.
  - **MERGE_NOT_MATCHED**: Specific merge part to store the define the attributes to insert when you don't find the key while merging (in combination with the MERGE_GRP)
  - **MERGE_MATCHED**: Specific merge part to identify the attributes to update when you find the key while merging (in combination with the MERGE_GRP)
  - **MERGE_ON**: Specific merge part to identify the key attributes to merge on (in combination with the MERGE_GRP)
  - ** UPDATE_SET**: Specific update part to identify the attributes to update when you find the key while updating (in combination with the UPD_GRP)
  - ** UPDATE_CONDITION**: Specific update part to identify the key attributes to update on (in combination with the UPD_GRP)

 

- **FILTER**: Filter component which will trigger ‘WHERE’. Filters contain a single attribute.

 

- **JOIN**: Join component to join to inline_views/CTE’s or tables together. Join filters also only contain a single attribute. Join components require 2 connections, one to each object being joined.
  available join types:
  - **LEFT_OUTER**
  - **RIGHT_OUTER**
  - **INNER**
  - **CROSS**
  - **FULL_OUTER**

 

- **INLINE_VIEW**: CTE/Inline view component
  - **SOURCE: **specific info keyword which will trigger ‘FROM'
  - **TARGET: **specific info keyword which will trigger ‘select' (in combination with the INL_V_GRP)
  - **JOINED: **specific info keyword to tell the template interpreter this is the joined cte/inline_view in a join. Otherwise, a 'FROM' would appear twice, so always used after a join component.
  - **AGGREGATED **: Variation of the target component, which triggers aggregation. This will result in a ‘group by’ clause

 

- **DISTINCT **: Distinct component triggers the distinct keyword (in combination with the INL_V_GRP)
  - **TARGET: **specific info keyword which will trigger 'select distinct' (in combination with the INL_V_GRP)

 

- **SET **: Set component, important is always to have the same name for each part of the set. It should also always be within the same component_group.
  set types:
  - **UNION**
  - **UNION_ALL**
  - **MINUS**
  - **INTERSECT**

### Level 4.1: ConnectsFrom (only needed for Groovy (ODI) and Jobscript(Talend)

This is used to make connections between components. This is needed for the graphical tools.

```
CONNECTSFROM ( COMPONENT_TYPE_NAME CONNECTION_SPECIFICATION? ) 
CONDITION_PARAMETER*
```

- **Connects from** Define the connection between components. Sometimes, an extra keyword is added to get a specific one while looping.
- **Component_type_name **→ the name of the other component which is connected to this one
- **Connection_specification **(if you use a $ sign in the component_type_name, by default, it gets replaced by the current loop number, by adding a specification, you can impact that loop number.
  - NEXT: Current loop number + 1
  - PREV: Current loop number - 1
  - FIRST: First loop number
  - LAST: Last loop number

Example:

```
		consists of inner join JOIN_TDFV_SRC_MEX_SRC
		RepeatedByObject MEX
		connectsFrom (JOIN_TDFV_SRC_LCI_SRC)
		connectsFrom (FILTER_MEX_SRC)
```

Important remark, a join must always have two connectsFrom as it connects two sides. Al the other components can have maximum one connectsFrom, source components do not connect from somewhere else, and thus do not need a connectsFrom.

For bridges, you can use the auto connectsFrom. This means you don’t need to specify the join condition. It will automatically add this.

```
        consists of  inner join JOIN_HUB_SRC_SNAPSHOTDATES$
        RepeatedByObject HUB$

		connectsFrom (BVLWT_SRC)
					connectionConditionedBy [(LOOP: GENERAL_LOOP = 1)]
				 	 (JOIN_HUB_SRC_SNAPSHOTDATES$ PREV)
					connectionConditionedBy [(LOOP: GENERAL_LOOP > 1)]
        auto connectsFrom (HUB_SRC$)

		consists of joined table HUB_SRC$
		RepeatedByObject HUB$
```

- **Condition_parameter**: Special case for connections: You can condition using an if then else structure. See example:
  
  - This would trigger behavior: try JOIN_INI_SRC_MEX_INR_SRC, try JOIN_INI_SRC_MEX_INR_SRC1 else take JOIN_INI_SRC_MEX_INR_SRC2.

## Level 5: Attribute

The "attribute" keyword defines an attribute. An attribute corresponds to a Signature Attribute in an object.

```
AGGREGATED? (ATTRIBUTE|ARTIFACT|ATTRIBUTEPART) DOLLAR? ATTRIBUTE_TYPE_NAME 
CONDITION_PARAMETER* 
COMPONENT_REPETITION_PARAMETER? 
EXPRESSION_STRUCTURE*
```

- **Aggregated:** This keyword (in combination with the aggregated keyword on the component level) will trigger an aggregation. This should be put in front of the attributes that you want to aggregate and so NOT appear in the group by.
- **Attribute: **This is the regular keyword, meaning every attribute with this Signature attribute will be searched for.
- **Artifact: **When there is no real attribute for this in the database. But if you want a temporary attribute to store a calculation, you use Artifact. It will ensure this is not looked up in the metadata and is just kept as an alias.
  

> ℹ️ **Remark**: You can never use a signature attribute/attribute type as an artifact

- **AttributePart: **If you repeat certain parts, you could connect them back together using this keyword. This will trigger the interpreter to search for the next part with the same attribute_type_name.
- **Dollar($): **Can be used to repeat. It will repeat for every table it can find from the table type you add in the repeated by. See example AttributePart.
- **Attribute_type_name: **Signature attribute of the attribute. See example AttributePart.
- **Condition parameter:** An attribute can be conditioned by AttributeConditionedBy. See example.
- **Component repetition parameter:** An attribute can be repeated by AttributeRepeatedBy. See example.

## Level 6: Expression

The real expression for a calculation, casting, ….

```
COLLECTIONDefinedByAttribute? LCB? 
GROUP? EXPRESSEDBY EXPRESSION_TEMPLATE 
CONDITION_PARAMETER* 
ATTRIBUTE_REPETITION_PARAMETER? CONCAT_WORD?
ALL? 
RCB? COLLECTIONcondition_parameter*
```

- **CollectionDefinedByAttribute **→ Normally, you can repeat an expression for an attribute by stating expressionDefinedByAttribute. In this case, where CollectionDefinedByAttribute is used, we can repeat a group of expressions for a particular attribute. This is used when the granularity of the repeated by attribute is the same as the target attribute, but you have multiple expression parts you want to condition
- **Group **→ To concatenate expression parts that are repeated or conditioned, a GROUP_1, GROUP_2 can be used to give an order to the expression parts.
- **Expressedby **→ A keyword to recognize the beginning of an expression. See the example group.
  - All attributes within an expression are automatically replaced if they are ‘unique’ (Added using the VaultSpeed studio or internal signatures which are unique.) or if they are related 1 on 1 to the attribute in the repeated by statement. If the interpreter can’t replace the attribute in the expression, it will throw an error.
- **Expression_template **→ A level beneath expression_structure. The expression itself. See the example group.
- **All **→ get all attributes of this type, used within a CollectionDefinedByAttribute to get all attributes of a specific Signature Attribute.
- **Condition parameter:** An expression can be conditioned by ExpressionConditionedBy. See the example group.
- **Component repetition parameter:** An attribute can be repeated by ExpressionRepeatedBy. See the example group.
- **Default expressed by: **If an attribute in the expression by would not exist, you can add a default expressed by the statement. This will then be used instead.

```
Attribute SUBSEQUENCE_ATTRIBUTE
	expressedBy SAT_SRC$.SUBSEQUENCE_ATTRIBUTE
	default expressedBy CASTFRMT[null]
	expressionDefinedByAttribute SSDV_TGT.SUBSEQUENCE_ATTRIBUTE
```

- **Concat_word: **When you use the group keyword, the concat_word is used to concatenate repetitions of the same group. Between groups, you have to add those keywords yourself. Possible concat words: AND, OR, VERTICAL (this will trigger || or +, based upon the target technology). See the example group.

# 3. Overall concepts

## 3.1. Looping

The $-sign is the general loop mechanism. It can be used for objects related through a relationship but also for splitted satellites.

### 3.1.1. Component group looping

Supergroup and subgroup level loops can be made on the component group for multiple cases of the same tab_type.

The loop is always activated by putting a $ before the group name and choosing a repeating Signature Object.

```
comp_group_start $ ALL_TIME_SLICES_GROUP
RepeatedByObject SAT
```

In this case, in the dependency definition, you will see aliases like SAT$1 - SAT$2 - …

So if you want to loop through them all, you will use the SAT as a repeater. If you only want the first one, use SAT$1 as a repeater.

**Dollar on template level: **The dollar symbol will be put before the template's name. This will repeat this template for every instance of the Signature Object you put after RepeatedByObject

**Dollar on component_supergroup level: **The dollar symbol will be put before the name of the component_supergroup. This will repeat this supergroup for every instance of the Signature Object you put after RepeatedByObject

**Dollar on component_group level:** The dollar symbol will be put before the name of the component_group. This will repeat this group for every  instance of the Signature Object you put after RepeatedbyObject

**Dollar on component_subgroup level:** The dollar symbol will be put before the name of the component_subgroup. This will repeat this subgroup for every instance of the Signature Object you put after RepeatedByObject

Every object you put $ behind during the loop will be replaced by the loop number.

So in the case above, if there are two satellites, SAT$1 and SAT$2, using the SAT to repeat will ensure both are used in the loop.

If it is the case to have a specific CTE for every Sat, this CTE will look like this:

```
comp_group_start $ SAT_SRC_GROUP$ INL_V_GRP
componentGroupConditionedBy [(TAB SAT$ : INSERT_ONLY_LOGIC = Y)]
componentGroupConditionedBy [(TAB PIT : SNAPSHOT_TIMESTAMP_TYPE != LOAD_TIMESTAMP)]
RepeatedbyObject SAT

	consists of target inline_view SAT_SRC$
	RepeatedByObject SAT$
	connectsFrom (SAT_ED_SRC$)

				Attribute OBJECT_H_KEY
				AttributeConditionedBy [(TAB PIT : DV_TYPE = H)]
					expressedBy SAT_ED_SRC$.OBJECT_H_KEY

	consists of source table SAT_ED_SRC$
	RepeatedByObject SAT$

comp_group_end
```

Component names (aliases) will get that same dollar symbol to ensure the right object is selected.  
In this case, within the group, every repetition will be for a particular satellite.

### 3.1.2. Attribute looping

This dollar symbol can also be introduced on the attribute level and works similarly for component group looping. A specific Signature Object is specified and will be used for finding the number of loops.

```
AttributePart $ OBJECT_P_H_KEY
AttributeConditionedBy [(TAB BRIDGE : CREATE_BRIDGE_HASH_KEY = Y)] 
attributerepeatedbycomponent HUB
	GROUP_2 expressedBy CHARCAST[HUB_SRC$.OBJECT_H_KEY] || @#HASHKEY_DELIMITER#
	expressionDefinedByAttribute BRIDGE_TGT.OBJECT_H_KEY$ VERTICAL
```

In the metadata, the compiler will look for all attributes of the OBJECT_H_KEY signature attribute for every hub/lnk/lnd (alias HUB) related to this bridge.

In the metadata, the object_h_key of the bridge has a specific ID to link to a particular related table.  
That is why for BRIDGE_TGT.OBJECT_H_KEY, you see an extra dollar at the end.

### 3.1.3. Multi-level looping

In a dependency view of a specific template signature object, we can see multiple levels of looping.

Looping is introduced if, for one Signature Object, in the dependency list, identical Signature objects appear for different objects.

For example satellites on a hub, they all have Signature object SAT, so to make them unique, a dollar is added: SAT$1 - SAT$2, …

In the other way, a SAT has always a dependency to only one HUB, so no need for looping.

To know if in a template a dollar is needed, check the dependency view for a template in the VaultSpeed Studio

![image](media://dbe8db35-2e84-4cd1-9522-3ca66af2126f)

#### **Examples:**

####   
3.1.3.1. Looping level 1

The satellite has the signature object SAT, but when dependent on a HUB, there are multiple signature objects in the dependency list.

sat_ms_addresses - sat_mm_addresses 

so looping is introduced SAT$1 - SAT$2

The loop is activated by adding a $ after the start of the level, in this case, the comp_subgroup_start. We repeat it by SAT so it will loop in this case two times based on the dependency list.  
All aliases within the group - subgroup should get this $, for example, this SAT_SRC$. In that way, you point to the correct dependency.  


```
		comp_subgroup_start $ SAT_SPLIT_SUBGROUP
		RepeatedByObject SAT

			consists of UNION set SSDV_TGT
			RepeatedByObject  SSDV

							Attribute OBJECT_H_KEY
								expressedBy SAT_SRC$.OBJECT_H_KEY
									expressionDefinedByAttribute SAT_SRC$.OBJECT_H_KEY

			consists of source table SAT_SRC$
			RepeatedByObject SAT$

		comp_subgroup_end
```

![image](media://3e050067-727a-4393-9712-2d7d3bbddbcb)


#### 3.1.3.2. Looping level 2

The satellite has the signature object SAT, but when dependent on a BRIDGE, there are multiple signature objects in the dependency list.

sat_ms_addresses - sat_mm_addresses - las_mm_cust_addr - sat_ms_customers_name

so looping is introduced SAT$1_$1 - SAT$2_$2

The loop is activated by adding a $ after the start of the level, in this case, the comp_subgroup_start. We repeat it by SAT to loop multiple times based on the dependency list.

For a bridge, the first level is the HUB - LNK - LND - LNA (DVO Signature object). The satellites upon those are the second level, second level looping uses $$.  
All aliases within the group - subgroup should get this $$, for example, this SAT_SRC$$. In that way, you point to the correct dependency.

The example below is a loop through the first level and then, within the first level subgroup loop, a loop through the second level with another subgroup.

```
		comp_subgroup_start $ BRIDGE_SUBGROUP
		RepeatedByObject DVO

            consists of  inner join JOIN_DVO_SRC$
            RepeatedByObject DVO$

            connectsfrom(BVLWT_SRC)
            auto connectsFrom (DVO_SRC$)

            consists of joined table DVO_SRC$
            RepeatedByObject DVO$

            comp_subgroup_start $ SAT_SUBGROUP
            RepeatedByObject SAT$

                consists of  inner join JOIN_SAT_SRC$$
                RepeatedByObject SAT$$

						Artifact GENERAL_EXPRESSION
							GROUP_1 expressedBy DVO_SRC$.OBJECT_H_KEY = SAT_SRC$$.OBJECT_H_KEY
								expressionDefinedByAttribute DVO_SRC$.OBJECT_H_KEY

                consists of joined inline_view SAT_SRC$$
                RepeatedByObject SAT$$

            comp_subgroup_end

		comp_subgroup_end
```

If you directly want to loop through the second level without looping first through the first level this can be done like this

```
comp_subgroup_start $ SAT_SUBGROUP
RepeatedByObject SAT

    consists of  inner join JOIN_SAT_SRC$$
    RepeatedByObject SAT$$

      Artifact GENERAL_EXPRESSION
		GROUP_1 expressedBy DVO_SRC$.OBJECT_H_KEY = SAT_SRC$$.OBJECT_H_KEY
		expressionDefinedByAttribute DVO_SRC$.OBJECT_H_KEY

    consists of joined inline_view SAT_SRC$$
    RepeatedByObject SAT$$

comp_subgroup_end
```


#### 3.1.3.3. Looping level X

If in the dependency list signature attributes have $1_$1_$1, then this is the third loop level, $1_$1_$1_$1 the fourth, …

So in the template, the number of $ needed when pointing to such a Signature object matches that number, so $$$ or $$$$.

## 3.2. Condition

 A condition is defined by the "[...]conditionedby" keyword.

The purpose of a condition parameter is to be able to condition on a choice of parameters.

```
(TEMPLATECONDITIONEDBY | COMPONENTSUPERGROUPCONDITIONEDBY |COMPONENTGROUPCONDITIONEDBY | COMPONENTSUBGROUPCONDITIONEDBY | COMPONENTCONDITIONEDBY | COMPONENTPARTCONDITIONEDBY | 
INTEGRATIONTYPECONDITIONEDBY | ATTRIBUTECONDITIONEDBY | EXPRESSIONCONDITIONEDBY |
CONNECTIONCONDITIONEDBY) [ CONDITION* ]
```

- **[...]conditionedby **→ A reference word to recognize the beginning of a condition. Prefix is added for readability.
- **condition **→ A level beneath condition_parameter. A condition specified in the template. Multiple conditions can be specified.

**Possible condition types:**

- Fixed tool parameter:
  - Parameter set inside the tool
- Table level property:
  - Property of an object, defined in the metadata
- Attribute property:
  - Property of an attribute, defined in the metadata
- Database parameter
  - Database type or language-specific condition
- Loop parameter
  - GENERAL_LOOP | SAT_SPLIT_LOOP

**Condition mechanism:**

- AND: If you want to check multiple conditions to be valid at once, put them between the same []
  - Example:
- OR: If you want to check if a condition or another is valid, repeat the conditionedBy and build your second condition
  - Example:

## 3.3. Repetition

A component repetition is defined by the "repeatedbyobject" keyword. A component repetition is to repeat several similar components.

```
REPEATEDBYOBJECT TAB_TYPE
        consists of source table BVLWT_SRC
        RepeatedByObject BVLWT
```

## 3.4. Function list

|  |  |  |
| --- | --- | --- |
| **  CODE** | **  DESCRIPTION** | **Example** |
| **  CHARCAST** | Convert to char | CHARCAST[TEMP_TABLE_SET.DELETE_FLAG] |
| **  CASTFRMT** | Convert to own datatype with format | CASTFRMT[STG_SRC.LOAD_TIMESTAMP] |
| **  CHARCASTFRMT** | Convert to char with format | CHARCASTFRMT[STG_SRC.LOAD_TIMESTAMP] |
| **  GCASTFRMT** | Convert to own datatype   
  with general parameter format | GCASTFRMT[$DELETE_FLAG] |
| **  GTIMECAST** | Convert to time datatype | GTIMECAST[@#CURRENT_RECORD_LOAD_END_DATE#] |
| **  NUMCAST** | Cast to number | NUMCAST[INI_SRC.TRANS_INDICATOR] |
| **  INTCAST** | Cast to integer | INTCAST[MEX_EX_SRC.LOAD_CYCLE_ID] |
| **HASHFUNC** | Hash function | HASHFUNC[ CHARCAST[DVO_SRC**$**.BUSINESS_KEY] || @#HASHKEY_DELIMITER# HASHFUNC] |

## 3.5. Object Properties

### 3.5.1. Data Vault

|  |  |  |  |
| --- | --- | --- | --- |
| **Parameter Code** | **Parameter Description** | **Parameter Values** | **Available for** |
| BUSINESSKEY_CONCATENATED | Is the Business key concatenated ? | Y / N | HUB |
| HAS_FOREIGN_KEY | Has the satellite foreign keys ? | Y / N | SAT |
| HARD_DELETE | Has Hard delete been activated for the satellite ? | Y / N | SAT - LDS |
| MULTI_ACTIVE_SAT | It the satellite a multi-active satellite ? | Y / N | SAT - LDS |
| HAS_SUBSEQUENCE_ATTRIBUTES | Does the multi-active satellite has subsequence attributes ? | Y / N | SAT - LDS |
| GROUPED | Is this Data Vault object a grouped object ? | Y / N | HUB – LNK – LND - RTS |
| SOURCE_SHORT_NAME | The short name of the source the satellite belongs to. | Free text | SAT – LKS - LDS |
| RTS_TYPE | On which object is the RTS based ? | HUB – LNK - LND | RTS |
| DV_TYPE | The Data Vault signature object | All Data Vault Signature objects | All Data Vault Signature objects |
| HAS_ATTRIBUTES | Does the object have descriptive attributes | Y / N | SAT - LDS |
| All Y-N parameters on Source & table level | All parameters which are configurable in the tool on Source and table level | Y / N | SAT – LKS – LDS - LAS |
| TABLE_NAME | The name of the object in the database | Free text | All Data Vault Signature objects |
| SIGNATURE_OBJECT | The signature objects upon a Data Vault signature object | All defined signature objects | All Data Vault Signature objects |
| DETECT_CHANGES_WITH_LCI | The load cycle id can be used for tracking changes, this is a combination of parameters (UPDATE_LOAD_CYCLE_ID_ON_UPDATE_DELETE = Y<br>or INSERT_ONLY_LOGIC = N)<br>and STREAMING_SOURCE = N) | Y / N | SAT – LKS – LDS |

### **3.5.2. Business Vault**

|  |  |  |  |
| --- | --- | --- | --- |
| **Parameter Code** | **Parameter Description** | **Parameter Values** | **Available for** |
| DV_TYPE | The Data Vault signature object | HUB – LNK – LND | PIT |
| PIT_TYPE | Is it a detail or snapshot pit | detail - snapshots | PIT |
| ISIZE | The size of the interval | Number | PIT |
| INTERVAL_TYPE | Which interval is chosen: day, month, year, … | SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, YEAR | PIT |
| SNAPSHOT_TIMESTAMP_TYPE | The timestamp chosen for the PIT | LOAD_TIMESTAMP/TRANS_TIMESTAMP | PIT |
| HAS_MULTIPLE_SATS | Does the pit have more then one satellite linked to it ? | Y / N | PIT |
| AGGREGATION | If there is a many to many link in the bridge, but not all of the linked hubs or there is a non historic link in the bridge, this parameter will be Y | Y / N | BRIDGE |
| HUB_INCOMPLETE_LINK$... | The many to many links which are in the bridge, but not all of the linked hubs will get a Y. | Y / N | BRIDGE |
| TABLE_NAME | The name of the object in the database | Free text | All Business Vault signature objects |
| SIGNATURE_OBJECT | The signature objects upon a Data Vault signature object | All defined signature objects | All Data Vault Signature objects |
| INSERT_ON_ERROR_RESOLUTION | This parameter indicates whether when a LAS reference error gets resolved, a new record is added, or the existing record gets updated.<br>If INSERT_ONLY_LOGIC  = Y or code is generated for ODI/Talend or code is generated for DBT and STORE_HUB_HASH_KEYS_IN_LINK_SAT = N then this parameter = Y | Y / N | LAS |

## 3.6. Attribute Properties

 **3.6.1. Data Vault**

|  |  |  |  |
| --- | --- | --- | --- |
| **Parameter Code** | **Parameter Description** | **Parameter Values** | **Available for** |
| DRIVING_KEY | Is the OBJECT_F_H_KEY a driving key ? | Y / N | LND |
| DATA_TYPE | The data type of an attribute | Free text | All attributes coming fromt the source |
| DATA_TYPE_GROUP | The data type group of an attribute | Free text | All attributes coming fromt the source |

 

## 3.7. Reserved Keywords

 

| Keyword | Level | Description | Example |
| --- | --- | --- | --- |
| : | Condition | Used in a condition definition to split condition type and condition | [(PARAM : DATA_QUALITY_BAD = N)] |
| ( | Condition | Used in a condition definition as start of single condition | [(PARAM : CAST_SOURCE_ATTRIBUTES = Y] |
| ) | Condition | Used in a condition definition as end of single condition | [(PARAM : EMPTYSTRING_IS_NULL = N] |
| [ | Function | Used in an expression definition as start of function | GCASTFRMT[MEX_INR_SRC.KEY_EXR] |
| ] | Function | Used in an expression definition as end of function | GCASTFRMT[MEX_INR_SRC.KEY_EXR] |
| { | Collection | Used in an collection definition as start of collection | ```
Attribute BUSINESS_KEY
    CollectionDefinedByAttribute TDFV_SRC.BUSINESS_SRC_KEY {

        GROUP_1 expressedBy COALESCE (UPPER(CHARCASTFRMT[TDFV_SRC.BUSINESS_SRC_KEY]), MEX_SRC.KEY_EXR)
            expressionConditionedBy [(PARAM : CAST_SOURCE_ATTRIBUTES = N)]
        GROUP_1 expressedBy COALESCE (UPPER (TDFV_SRC.BUSINESS_SRC_KEY), MEX_SRC.KEY_EXR)
            expressionConditionedBy [(PARAM : CAST_SOURCE_ATTRIBUTES = Y)]

    } CollectionConditionedBy [(COL BUSINESS_SRC_KEY : DATA_TYPE_GROUP != CHAR)]
``` |
| } | Collection | Used in an collection definition as end of collection | See { |
| < | Condition | Used in a condition definition as < | [(LOOP: GENERAL_LOOP < 1)] |
| <= | Condition | Used in a condition definition as <= | [(LOOP: GENERAL_LOOP <= 1)] |
| = | Condition | Used in a condition definition as = | [(PARAM : CAST_SOURCE_ATTRIBUTES = N)] |
| != | Condition | Used in a condition definition as Not Equal | [(COL OTHER_ATTR : DATA_TYPE_GROUP != CHAR)] |
| > | Condition | Used in a condition definition as > | [(LOOP: GENERAL_LOOP > 1)] |
| >= | Condition | Used in a condition definition as >= | [(LOOP: GENERAL_LOOP >= 1)] |
| $ | Loop | Used in the template as loop mechanism | comp_subgroup_start $ JOIN_HUB_TEMP_SRC_SUBGROUP  
RepeatedByObject HUB_TEMP |
| ADD | Attribute | Used on attribute to trigger Add attribute ddl for alter statements | ADD Attribute FOREIGN_KEY |
| AGGREGATED | Aggregation | Used on Component and Attribute level for aggregation | ```
consists of aggregated table HUB_TGT
RepeatedByObject HUB
connectsFrom (HUB_TEMP_SRC)

            Attribute OBJECT_H_KEY 
                expressedBy HUB_TEMP_SRC.N_OBJECT_H_KEY
                expressionDefinedByAttribute HUB_TEMP_SRC.N_OBJECT_H_KEY

            Aggregated Attribute LOAD_TIMESTAMP
                expressedBy MIN(HUB_TEMP_SRC.LOAD_TIMESTAMP)
                expressionDefinedByAttribute HUB_TEMP_SRC.LOAD_TIMESTAMP
``` |
| ALL | Collection | Used within a collection to repeat all attributes of a signature attribute at once. | ```
CollectionDefinedByAttribute TDFV_SRC.FOREIGN_KEY {

    GROUP_1 expressedBy CASE WHEN TDFV_SRC.TRANS_TYPE = @#TRANSACTION_TYPE_UPDATE# AND LAG (TDFV_SRC.FOREIGN_KEY,1) OVER (PARTITION BY
    GROUP_2 expressedBy TDFV_SRC.PRIMARY_KEY
        expressionDefinedByAttribute TDFV_SRC.PRIMARY_KEY ALL
    GROUP_3 expressedBy ORDER BY TDFV_SRC.TRANS_TIMESTAMP
    GROUP_4 expressedBy , TDFV_SRC.CDC_LOGPOSITION
        expressionConditionedBy [(PARAM : CDC_LOGPOSITION_AVAILABLE = Y)]
    GROUP_5 expressedBy ) != TDFV_SRC.FOREIGN_KEY THEN 1 ELSE 0 END

}
``` |
| ALTER_TABLE_COLUMN | Component | Used on component level to trigger the altering of attributes on a table. | ```
comp_group_start DDL_GROUP CREA_GRP
RepeatedbyObject HUB 

    consists of ALTER_TABLE_COLUMN table HUB_TGT
    RepeatedByObject HUB 

                ADD Attribute SOURCE_SYSTEM_NAME

comp_group_end
``` |
| AND | Repetition | Used as a keyword after the repetition attribute to concatenate repetitions. | ```
GROUP_1 expressedBy BRIDGE_SRC.OBJECT_H_KEY = MIV.OBJECT_H_KEY
  expressionConditionedBy [(TAB BRIDGE : CREATE_BRIDGE_HASH_KEY = N)]
  expressionDefinedByAttribute BRIDGE_SRC.OBJECT_H_KEY AND 
``` |
| ARTIFACT | Attribute | Used as a keyword instead of the default attribute keyword to make sure the interpreter doesn’t look for this signature attribute in the database. | ```
Artifact GENERAL_EXPRESSION
    expressedBy MEX_SRC.RECORD_TYPE = @#NULL_RECORD_TYPE#
        expressionDefinedByAttribute MEX_SRC.RECORD_TYPE
``` |
| ATTRIBUTE | Attribute | Used as a keyword do define the target attribute | ```
Attribute LOAD_TIMESTAMP
    expressedBy MIV.LOAD_TIMESTAMP
    expressionDefinedByAttribute MIV.LOAD_TIMESTAMP
``` |
| ATTRIBUTECONDITIONEDBY | Condition | Condition keyword for attributes. | ```
Attribute OBJECT_P_H_KEY
AttributeConditionedBy [(TAB BRIDGE : CREATE_BRIDGE_HASH_KEY = Y)]
    expressedBy MIV.OBJECT_P_H_KEY
    expressionDefinedByAttribute MIV.OBJECT_P_H_KEY
``` |
| ATTRIBUTEPART | Attribute | Attribute keyword to trigger concat | ```
AttributePart OBJECT_P_H_KEY
AttributeConditionedBy [(TAB BRIDGE : CREATE_BRIDGE_HASH_KEY = Y)]
    GROUP_1 expressedBy HASHFUNC[

AttributePart $ OBJECT_P_H_KEY
AttributeConditionedBy [(TAB BRIDGE : CREATE_BRIDGE_HASH_KEY = Y)]
attributerepeatedbycomponent HUB
    GROUP_2 expressedBy CHARCAST[HUB_SRC$.OBJECT_H_KEY] || @#HASHKEY_DELIMITER#
    expressionDefinedByAttribute BRIDGE_TGT.OBJECT_H_KEY$ VERTICAL

AttributePart OBJECT_P_H_KEY
AttributeConditionedBy [(TAB BRIDGE : CREATE_BRIDGE_HASH_KEY = Y)]
    GROUP_3 expressedBy HASHFUNC]
``` |
| ATTRIBUTEREPEATEDBYCOMPONENT | Repetition | Repetition keyword for attributes. | ```
AttributePart $ OBJECT_P_H_KEY
AttributeConditionedBy [(TAB BRIDGE : CREATE_BRIDGE_HASH_KEY = Y)]
attributerepeatedbycomponent HUB
    GROUP_2 expressedBy CHARCAST[HUB_SRC$.OBJECT_H_KEY] || @#HASHKEY_DELIMITER#
    expressionDefinedByAttribute BRIDGE_TGT.OBJECT_H_KEY$ VERTICAL
``` |
| AUTO | Join | Used for bridges and will auto create the join condition. | ```
comp_subgroup_start $ BRIDGE_SUBGROUP
RepeatedByObject HUB

consists of  inner join JOIN_HUB_SRC_SNAPSHOTDATES$
RepeatedByObject HUB$

connectsFrom (BVLWT_SRC)
            connectionConditionedBy [(LOOP: GENERAL_LOOP = 1)]
              (JOIN_HUB_SRC_SNAPSHOTDATES$ PREV)
            connectionConditionedBy [(LOOP: GENERAL_LOOP > 1)]
auto connectsFrom (HUB_SRC$)

consists of joined table HUB_SRC$
RepeatedByObject HUB$

comp_subgroup_end
``` |
| CHAR | Condition | Used as a data type group in the conditioning of an expression. | ```
Attribute OTHER_ATTR_ORG
attributeConditionedBy [(PARAM : DATA_QUALITY_BAD = Y)]
    expressedBy TDFV_SRC.OTHER_ATTR
        expressionConditionedBy [(COL OTHER_ATTR : DATA_TYPE_GROUP != CHAR)]
        expressionDefinedByAttribute TDFV_SRC.OTHER_ATTR
``` |
| COL | Condition | Keyword to trigger lookup of attribute calculated parameter | ```
Attribute PRIMARY_KEY 
expressedBy COALESCE (INI_SRC.PRIMARY_KEY , GCASTFRMT[MEX_INR_SRC.KEY_EXR])
    expressionConditionedBy [(PARAM : CAST_SOURCE_ATTRIBUTES = N)(COL PRIMARY_KEY : DATA_TYPE_GROUP != CHAR)] 
    expressionDefinedByAttribute INI_SRC.PRIMARY_KEY
``` |
| COLLECTIONCONDITIONEDBY | Condition | Condition keyword for collections. | ```
Attribute $ BUSINESS_FK_KEY$
attributeConditionedBy [(TAB EXT_PK$ : PK_SAME_AS_BK = Y)]
attributerepeatedbycomponent EXT_PK 
    CollectionDefinedByAttribute PREP_EXCEP.FOREIGN_KEY$ { 
        
        GROUP_1 expressedBy COALESCE ( UPPER (CHARCASTFRMT[PREP_EXCEP.FOREIGN_KEY$]) , MEX_SRC.KEY_EXR)
            expressionConditionedBy [(PARAM : DATA_QUALITY_BAD = N)]
        GROUP_1 expressedBy COALESCE ( UPPER (PREP_EXCEP.FOREIGN_KEY$) , MEX_SRC.KEY_EXR)
            expressionConditionedBy [(PARAM : DATA_QUALITY_BAD = Y)]

    } CollectionConditionedBy [(COL FOREIGN_KEY : DATA_TYPE_GROUP != CHAR)]
``` |
| CollectionDefinedByAttribute | Repetition | Repetition keyword for collections. | See COLLECTIONCONDITIONEDBY |
| COMMA | Repetition | Used as a keyword after the repetition attribute to concatenate repetitions. | ```
Attribute DUMMY
    GROUP_1 expressedBy ROW_NUMBER() OVER (PARTITION BY
    GROUP_2 expressedBy STG_INR_SRC.OBJECT_L_H_KEY
        expressionDefinedByAttribute STG_INR_SRC.OBJECT_L_H_KEY COMMA                     
    GROUP_3 expressedBy ORDER BY STG_INR_SRC.LOAD_TIMESTAMP
    GROUP_4 expressedBy , STG_INR_SRC.CDC_LOGPOSITION
        expressionConditionedBy [(PARAM : CDC_LOGPOSITION_AVAILABLE = Y)(PARAM : USE_CDC_TS_AS_LOAD_DATES = Y)]
        expressionDefinedByAttribute STG_INR_SRC.CDC_LOGPOSITION
    GROUP_5 expressedBy )
``` |
| COMP_GROUP_END | Comp_group | Keyword to identify end of a component group | ```
comp_group_start TRUNCATE_GROUP TRUNC_GRP
RepeatedbyObject BRIDGE 

    consists of target table BRIDGE_TGT
    RepeatedByObject BRIDGE 
            
comp_group_end
``` |
| COMP_GROUP_START | Comp_group | Keyword to identify start of a component group | see COMP_GROUP_END |
| COMP_SUBGROUP_END | Comp_group | Keyword to identify end of a component subgroup | ```
comp_subgroup_start UNKNOWN_FILTER_SUBGROUP
componentsubgroupConditionedBy [(PARAM : INSERT_ONLY_LOGIC = Y)]
RepeatedByObject LND

consists of filter FILTER_LND_SRC
RepeatedByObject LND

            AttributePart $ GENERAL_EXPRESSION
            attributerepeatedbycomponent HUB
                GROUP_1 expressedBy HUB_SRC$.OBJECT_H_KEY IS NULL
                    expressionDefinedByAttribute HUB_SRC$.OBJECT_H_KEY OR
comp_subgroup_end
``` |
| COMP_SUBGROUP_START | Comp_group | Keyword to identify start of a component subgroup | see COMP_SUBGROUP_END |
| COMP_SUPERGROUP_END | Comp_group | Keyword to identify end of a component supergroup | ```
comp_supergroup_start LKS_INR_TGT   // insert new records in the LKS tables
componentSuperGroupConditionedBy [(PARAM : CDC_RELIABLE = Y)]
    
    comp_group_start SELECT_GROUP SEL_GRP
    RepeatedbyObject STG
      
    comp_group_end

    comp_group_start STG_SRC_GROUP INL_V_GRP
    RepeatedbyObject STG

    comp_group_end

    comp_group_start INSERT_END_GROUP INS_GRP
    RepeatedbyObject LKS

    comp_group_end
    
comp_supergroup_end
``` |
| COMP_SUPERGROUP_START | Comp_group | Keyword to identify start of a component supergroup | see COMP_SUPERGROUP_END |
| COMPONENTCONDITIONEDBY | Condition | Condition keyword for components. | ```
consists of filter FILTER_SAT_SRC$
componentConditionedBy [(PARAM : INSERT_ONLY_LOGIC = Y)]
RepeatedByObject SAT_PK$
connectsFrom (JOIN_CHANGE_INDEX_SAT_SRC$)
``` |
| COMPONENTGROUPCONDITIONEDBY | Condition | Condition keyword for components groups. | ```
comp_group_start EXISTS_GROUP EXISTS_GRP
componentgroupConditionedBy [(PARAM : USE_MERGE_STATEMENT = N)(DATABASE : ETL_LANG != GROOVY)]
RepeatedbyObject BRIDGE 
``` |
| RepeatedbyObject | Repetition | Condition keyword for components. | see COMPONENTGROUPCONDITIONEDBY |
| RepeatedByObject | Repetition | Repetition keyword for components. | see COMPONENTCONDITIONEDBY |
| COMPONENTSUBGROUPCONDITIONEDBY | Condition | Condition keyword for components subgroups. | see COMP_SUBGROUP_END |
| RepeatedByObject | Repetition | Repetition keyword for components subgroups. | see COMP_SUBGROUP_END |
| COMPONENTSUPERGROUPCONDITIONEDBY | Condition | Condition keyword for components supergroups. | see COMP_SUPERGROUP_END |
| RepeatedByObject | Repetition | Repetition keyword for components supergroups. | see COMP_SUPERGROUP_END |
| CONNECTIONCONDITIONEDBY | Condition | Condition keyword for connections. | see AUTO |
| CONNECTSFROM | Connection | Keyword for connection | see AUTO |
| CONSISTS | Component | Keyword for components | see COMPONENTCONDITIONEDBY |
| CREA_GRP | Comp_group | DDL Component group keyword | ```
comp_group_start DDL_GROUP CREA_GRP
RepeatedbyObject HUB_TEMP

    consists of CREATE_TABLE table HUB_TEMP_TGT
    RepeatedByObject HUB_TEMP

            Attribute OBJECT_H_KEY

            Attribute LOAD_TIMESTAMP

            Attribute LOAD_CYCLE_ID

            Attribute CONCAT_BUSINESS_KEY

            Attribute SOURCE_SYSTEM_NAME
            attributeConditionedBy [(TAB HUB : HUB_TYPE_SHORT_NAME = MM )]

            Attribute N_OBJECT_H_KEY
              
comp_group_end
``` |
| CREATE_TABLE | Component | DDL Component keyword to trigger create table statement | see CREA_GRP |
| CROSS | Component | Cross join keyword | ```
consists of cross join JOIN_EXT_SRC_MEX_SRC 
RepeatedByObject MEX
connectsFrom (EXT_SRC)
connectsFrom (FILTER_MEX_SRC)

            Artifact GENERAL_EXPRESSION             
                expressedBy 1 = 1
``` |
| DATABASE | Condition | Condition keyword to trigger check on database | [(DATABASE : DB_TYPE = ORACLE)] |
| DBSQL | ETL_LANG | Language possibility in a condition | ```
Template EXT_TGT
templateConditionedBy [(DATABASE : ETL_LANG = GROOVY DBSQL)]
``` |
| DEF_GRP | Comp_group | Definition Component group keyword | ```
comp_group_start DEFINITION_GROUP DEF_GRP
RepeatedbyObject LKS_TEMP
``` |
| DEL_GRP | Comp_group | Delete Component group keyword | ```
comp_group_start DELETE_GROUP DEL_GRP
RepeatedbyObject LDS
``` |
| DISTINCT | Component | Distinct component (to be use in an inl_v_grp) | ```
consists of target distinct LAS_SET
RepeatedByObject LAS
connectsFrom (FILTER_MEX_SET_SRC)
``` |
| DROP | DDL | Additional keyword on attribute level to drop attribute | ```
DROP Attribute OBJECT_F_H_KEY
AttributeConditionedBy [(PARAM : STORE_HUB_HASH_KEYS_IN_LINK_SAT = N)] 
``` |
| DROP_TABLE | Component | DDL Component keyword to trigger drop table statement | ```
consists of DROP_TABLE table HUB_TEMP_TGT
RepeatedByObject HUB_TEMP
``` |
| EXISTS_GRP | Comp_group | Exists Component group keyword | ```
comp_group_start EXISTS_GROUP EXISTS_GRP
componentgroupConditionedBy [(PARAM : USE_MERGE_STATEMENT = N)(DATABASE : ETL_LANG != GROOVY)]
RepeatedbyObject BRIDGE 

    consists of target table BRIDGE_TGT
    RepeatedByObject BRIDGE
    connectsFrom (FILTER_BRIDGE_SRC)

                Attribute DUMMY
                    expressedBy 1
                        
    consists of source table BRIDGE_SRC
    RepeatedByObject BRIDGE

    consists of filter FILTER_BRIDGE_SRC
    RepeatedByObject BRIDGE 
    connectsFrom (BRIDGE_SRC)
        
                Artifact GENERAL_EXPRESSION
                    expressedBy BRIDGE_SRC.OBJECT_P_H_KEY = MIV.OBJECT_P_H_KEY
                        expressionConditionedBy [(TAB BRIDGE : CREATE_BRIDGE_HASH_KEY = Y)]
                        expressionDefinedByAttribute BRIDGE_SRC.OBJECT_P_H_KEY
                    GROUP_1 expressedBy BRIDGE_SRC.OBJECT_H_KEY = MIV.OBJECT_H_KEY
                        expressionConditionedBy [(TAB BRIDGE : CREATE_BRIDGE_HASH_KEY = N)]
                        expressionDefinedByAttribute BRIDGE_SRC.OBJECT_H_KEY AND 
comp_group_end
``` |
| EXPRESSEDBY | Expression | Keyword for the start of an expression. | expressedBy BRIDGE_SRC.OBJECT_P_H_KEY = MIV.OBJECT_P_H_KEY |
| EXPRESSIONCONDITIONEDBY | Condition | Condition keyword for expressions. | ```
expressedBy UNIQUEDATETIME[LCI_SRC.LOAD_TIMESTAMP UNIQUEDATETIME]
expressionConditionedBy [(PARAM : INTRA_LOADCYCLE_CHANGES = Y) (PARAM : SRC_CDC = NO_CHANGE_DATA_CAPTURE)]
``` |
| expressionDefinedByAttribute | Repetition | Repetition keyword for expressions. | ```
GROUP_2 expressedBy CHARCAST[HUB_SRC$.OBJECT_H_KEY] || @#HASHKEY_DELIMITER#
expressionDefinedByAttribute BRIDGE_TGT.OBJECT_H_KEY$ VERTICAL
``` |
| FILTER | Component | Component keyword to trigger where statement | ```
consists of filter FILTER_MIV_SRC
RepeatedByObject BRIDGE
``` |
| FIRST | Connection | Connection keyword to point to first in loop | ```
consists of aggregated inline_view MIV
RepeatedByObject EXT
connectsFrom (JOIN_FK$ FIRST)
``` |
| FULL_OUTER | Join | Full outer join keyword | ```
consists of full_outer join JOIN_RESULT_SET_MEX_SRC
RepeatedByObject MEX
connectsFrom (RESULT_SET_NC_VALUES)
connectsFrom (MEX_SRC_BK)

            Artifact GENERAL_EXPRESSION
                expressedBy 1 = 1
``` |
| GROUP | Expression | Keyword to group expressions | GROUP_1 expressedBy COALESCE ( |
| INL_V_GRP | Comp_group | CTE Component group keyword | ```
comp_group_start PREVIOUS_VERSION_GROUP INL_V_GRP
componentgroupConditionedBy [(PARAM : CDC_UPDATE_RECORD_ALL_ATTRIBUTES = N)]
RepeatedbyObject EXT
``` |
| INLINE_VIEW | Component | CTE Component keyword | ```
consists of target inline_view PREVIOUS_VERSION
RepeatedByObject EXT
connectsFrom (ALL_TIME_SLICES)
``` |
| INNER | Component | Inner join keyword | ```
consists of inner join JOIN_RESULT_SET_MEX_SRC
RepeatedByObject MEX
connectsFrom (RESULT_SET_NC_VALUES)
connectsFrom (MEX_SRC_BK)

            Artifact GENERAL_EXPRESSION
                expressedBy 1 = 1
``` |
| INS_GRP | Comp_group | Insert/view Component group keyword | ```
comp_group_start INSERT_END_GROUP INS_GRP
RepeatedbyObject EXT
``` |
| INTERSECT | Component | Intersect set keyword | ```
consists of INTERSECT set CREATE_SET_NC_VALUES
RepeatedByObject EXT 
connectsFrom (CHANGE_INDEX)
``` |
| JOIN | Component | Component keyword to trigger join statement | ```
consists of inner join JOIN_HUB_SRC_RESULT_SAT_VALUES
componentConditionedBy [(TAB EXT : OBJECT_TYPE = BUSINESS_OBJECT)(TAB EXT : BUSINESSKEY_CONCATENATED = N)(PARAM : STORE_BK_FIELDS_IN_SAT = N)]
RepeatedByObject HUB
connectsFrom (JOIN_PREVIOUS_VERSION_RESULT_SAT_VALUES)
connectsFrom (HUB_SRC)

            Artifact GENERAL_EXPRESSION
                expressedBy RESULT_SAT_VALUES.OBJECT_H_KEY = HUB_SRC.OBJECT_H_KEY
``` |
| JOINED | Component | Component keyword to trigger table for join statement | ```
consists of joined table HUB_SRC
componentConditionedBy [(TAB EXT : OBJECT_TYPE = BUSINESS_OBJECT)(TAB EXT : BUSINESSKEY_CONCATENATED = N)(PARAM : STORE_BK_FIELDS_IN_SAT = N)]
RepeatedByObject HUB
``` |
| LAST | Connection | Connection keyword to point to last in loop | ```
consists of aggregated inline_view MIV
RepeatedByObject EXT
connectsFrom (JOIN_FK$ LAST)
``` |
| LEFT_OUTER | Component | Left outer join keyword | ```
consists of left_outer join JOIN_RESULT_SET_MEX_SRC
RepeatedByObject MEX
connectsFrom (RESULT_SET_NC_VALUES)
connectsFrom (MEX_SRC_BK)

            Artifact GENERAL_EXPRESSION
                expressedBy 1 = 1
``` |
| LOOP | Condition | Condition keyword to filter on loops | connectionConditionedBy [(LOOP: GENERAL_LOOP = 1)] |
| MERGE_GRP | Comp_group | Merge Component group keyword | ```
comp_group_start MERGE_END_GROUP MERGE_GRP
componentgroupConditionedBy [(PARAM : USE_MERGE_STATEMENT = Y)]
RepeatedbyObject LDS

    consists of merge_on table LDS_ED_TGT
    RepeatedByObject LDS
    connectsFrom (FILTER_LOAD_END_DATE)

                Attribute OBJECT_L_H_KEY
                    expressedBy FILTER_LOAD_END_DATE.OBJECT_L_H_KEY
                    expressionDefinedByAttribute FILTER_LOAD_END_DATE.OBJECT_L_H_KEY

    consists of merge_matched table LDS_ED_TGT
    RepeatedByObject LDS
    connectsFrom (FILTER_LOAD_END_DATE)

                Attribute LOAD_END_TIMESTAMP
                    expressedBy FILTER_LOAD_END_DATE.LOAD_END_TIMESTAMP
                    expressionDefinedByAttribute FILTER_LOAD_END_DATE.LOAD_END_TIMESTAMP

    consists of merge_not_matched table LDS_ED_TGT
    componentConditionedBy [(PARAM : CDC_RELIABLE = N)]
    RepeatedByObject LDS
    connectsFrom (FILTER_LOAD_END_DATE)

                Attribute OBJECT_L_H_KEY
                    expressedBy FILTER_LOAD_END_DATE.OBJECT_L_H_KEY
                        expressionDefinedByAttribute FILTER_LOAD_END_DATE.OBJECT_L_H_KEY
                Attribute LOAD_TIMESTAMP
                    expressedBy FILTER_LOAD_END_DATE.LOAD_TIMESTAMP
                        expressionDefinedByAttribute FILTER_LOAD_END_DATE.LOAD_TIMESTAMP

    consists of source inline_view FILTER_LOAD_END_DATE
    RepeatedByObject LDS_TEMP

comp_group_end
``` |
| MERGE_MATCHED | Component | Merge Component keyword for matched | see MERGE_GRP |
| MERGE_NOT_MATCHED | Component | Merge Component keyword for not matched | see MERGE_GRP |
| MERGE_ON | Component | Merge Component keyword for key on merge | see MERGE_GRP |
| MINUS | Component | Minus set keyword | ```
consists of MINUS set CREATE_SET_NC_VALUES
RepeatedByObject EXT 
connectsFrom (CHANGE_INDEX)
``` |
| NEXT | Connection | Connection keyword to point to next in loop | ```
consists of aggregated inline_view MIV
RepeatedByObject EXT
connectsFrom (JOIN_FK$ NEXT)
``` |
| NOT | Expression | Keyword in expression for not exists | ```
Artifact GENERAL_EXPRESSION
    expressedBy NOT EXISTS
    expressionConditionedBy [(DATABASE : ETL_LANG != GROOVY)]
``` |
| NUMBER | Data type | Expression Condition property for data types | [(COL OTHER_ATTR : DATA_TYPE_GROUP = NUMBER)] |
| OF | Component | Keyword next to consists to identify component level | consists of target inline_view MIV |
| OR | Repetition | Used as a keyword after the repetition attribute to concatenate repetitions. | ```
Artifact GENERAL_EXPRESSION
    GROUP_1 expressedBy STG_DL_SRC.ERROR_CODE = 0
        expressionDefinedByAttribute STG_DL_SRC.ERROR_CODE OR
``` |
| OTHER | Data type | Expression Condition property for data types | [(COL OTHER_ATTR : DATA_TYPE_GROUP = OTHER)] |
| PARAM | Condition | Keyword to trigger parameter value search | [(PARAM : USE_MERGE_STATEMENT = Y)] |
| PREV | Connection | Connection keyword to point to previous in loop | ```
consists of aggregated inline_view MIV
RepeatedByObject EXT
connectsFrom (JOIN_FK$ PREV)
``` |
| REC_INL_V_GRP | Comp_group | Keyword for component group for recursive CTE | ```
comp_group_start SNAPSHOTDATES_GROUP REC_INL_V_GRP
    componentGroupConditionedBy [(TAB SSDV : PIT_TYPE = SNAPSHOTS)]
    RepeatedbyObject SSDV
``` |
| REC_TABLE | Component | Keyword for component when starting from recursive view/table | ```
consists of source rec_table SSDV_SRC
componentConditionedBy [(TAB PIT : PIT_TYPE = SNAPSHOTS)]
RepeatedByObject SSDV
``` |
| RIGHT_OUTER | Component | Right outer join keyword | ```
consists of right_outer join JOIN_RESULT_SET_MEX_SRC
RepeatedByObject MEX
connectsFrom (RESULT_SET_NC_VALUES)
connectsFrom (MEX_SRC_BK)

            Artifact GENERAL_EXPRESSION
                expressedBy 1 = 1
``` |
| SEL_GRP | Comp_group | Select Component group keyword (only for talend) | ```
comp_group_start SELECT_GROUP SEL_GRP
RepeatedbyObject MEX 

    consists of source table MEX_SRC
    RepeatedByObject MEX
            
            Attribute RECORD_TYPE
            
            Attribute KEY_EXR

            Attribute OTH_EXR       
            

comp_group_end
``` |
| SEPARATOR | Repetition | Expression repetition keyword to use a specific seperator. | expressionDefinedByAttribute STG_SRC$.BUSINESS_FK_KEY SEPARATOR [VERTICAL @#HASHKEY_DELIMITER# VERTICAL] |
| SET | Component | Component keyword to trigger set | ```
consists of UNION set CREATE_SET_NC_VALUES
RepeatedByObject EXT 
connectsFrom (CHANGE_INDEX)
``` |
| SOURCE | Component | Component keyword to trigger from keyword | ```
consists of source table BVLWT_SRC
RepeatedByObject BVLWT
``` |
| TAB | Condition | Keyword to trigger calculated parameter value search | attributeConditionedBy [(TAB STG_FK$ : BUSINESSKEY_CONCATENATED = Y)] |
| TABLE | Component | Component keyword to identify database table | ```
consists of source table BVLWT_SRC
RepeatedByObject BVLWT
``` |
| TARGET | Component | Component keyword to trigger action to a certain table or the creation of the CTE | ```
consists of target table BRIDGE_TGT
RepeatedByObject BRIDGE
connectsFrom (FILTER_BRIDGE_SRC)
``` |
| TEMPLATE | Template | Template keyword to identify start template | Template BRIDGE_TGT |
| TEMPLATECONDITIONEDBY | Condition | Condition keyword for Templates. | ```
Template LAS_DFL_TGT    // update deleted records
templateConditionedBy [(PARAM : INSERT_ONLY_LOGIC = N)(PARAM : INSERT_ON_DELETE = N)]
``` |
| TRUNC_GRP | Comp_group | Truncate Component group keyword | ```
comp_group_start TRUNCATE_GROUP TRUNC_GRP
RepeatedbyObject BRIDGE 

    consists of target table BRIDGE_TGT
    RepeatedByObject BRIDGE 
            
comp_group_end
``` |
| UNION | Component | Union set keyword | ```
consists of UNION set CREATE_SET_NC_VALUES
RepeatedByObject EXT 
connectsFrom (CHANGE_INDEX)
``` |
| UNION_ALL | Component | Union all set keyword | ```
consists of UNION_ALL set CREATE_SET_NC_VALUES
RepeatedByObject EXT 
connectsFrom (CHANGE_INDEX)
``` |
| UPD_GRP | Comp_group | Update Component group keyword | ```
comp_group_start UPDATE_END_GROUP UPD_GRP
componentgroupConditionedBy [(PARAM : USE_MERGE_STATEMENT = N)]
RepeatedbyObject LAS                                                                       

    consists of update_set table LAS_DFL_TGT
    RepeatedByObject LAS
    connectsFrom (MIV_DFL)              

                Attribute DELETE_FLAG                       
                    expressedBy MIV_DFL.DELETE_FLAG
                    expressionDefinedByAttribute MIV_DFL.DELETE_FLAG 

                Attribute TRANS_TIMESTAMP
                AttributeConditionedBy [(PARAM : SRC_CDC = CHANGE_DATA_CAPTURE)(PARAM : USE_CDC_TS_AS_LOAD_DATES = N)]
                AttributeConditionedBy [(PARAM : SRC_CDC = MODIFICATION_DATE)(PARAM : USE_CDC_TS_AS_LOAD_DATES = N)] 
                    expressedBy MIV_DFL.TRANS_TIMESTAMP 

                Attribute LOAD_END_TIMESTAMP
                AttributeConditionedBy [(PARAM : CLOSE_DELETED_RECORDS = Y)]
                    expressedBy MIV_DFL.LOAD_END_TIMESTAMP                              

                Attribute LOAD_CYCLE_ID
                AttributeConditionedBy [(PARAM : UPDATE_LOAD_CYCLE_ID_ON_UPDATE_DELETE = Y)]
                    expressedBy MIV_DFL.LOAD_CYCLE_ID
                    expressionDefinedByAttribute MIV_DFL.LOAD_CYCLE_ID

    consists of source inline_view MIV_DFL
    RepeatedByObject LAS_TEMP

    consists of update_condition table LAS_DFL_TGT
    RepeatedByObject LAS
    connectsFrom (MIV_DFL)

                Attribute OBJECT_L_H_KEY
                    expressedBy MIV_DFL.OBJECT_L_H_KEY
                        expressionDefinedByAttribute MIV_DFL.OBJECT_L_H_KEY
                        
                Attribute LOAD_TIMESTAMP                                        
                    expressedBy MIV_DFL.LOAD_TIMESTAMP
                        expressionDefinedByAttribute MIV_DFL.LOAD_TIMESTAMP

                Attribute CDC_LOGPOSITION
                attributeConditionedBy [(PARAM : CDC_LOGPOSITION_AVAILABLE = Y)(PARAM : USE_CDC_TS_AS_LOAD_DATES = Y)]
                    expressedBy MIV_DFL.CDC_LOGPOSITION
                        expressionDefinedByAttribute MIV_DFL.CDC_LOGPOSITION                  

comp_group_end
``` |
| UPDATE_CONDITION | Component | Update Component keyword for key | see UPD_GRP |
| UPDATE_SET | Component | Update Component keyword for set | see UPD_GRP |
| VERTICAL | Repetition | Keyword in expression repetition clause | expressionDefinedByAttribute STG_DL_INR_SRC.OTHER_ATTR VERTICAL |