Satellite

A Satellite stores the descriptive data of a Hub's business keys and its history in a table of the Raw Vault layer. Use it for attributes that change over time, such as a customer's name and type. After each load, the result view shows every version of each key with its validity.

Sources and relationships

A Satellite reads Stages, RawVault Composites and Store Entities of a linked Data Store project, in one or more dataflows. It has exactly one relationship to a Hub, and its foreign-key terms must be mapped. PIT, Current View, History View, BusinessVault Composite, Vault Out and the Business Vault types can read it.

Create a Satellite

• With the wizard: open the menu of a Stage, RawVault Composite or Store Entity, choose Automate and then Create Satellite. Its steps are Create Model Object, Create Dataflow, Create Relations, Map Foreign Key Terms, Map Selected Terms and Add to View. See Create a Model Object with the wizard.
  
• Manually: create a model object of type Satellite in the Raw Vault layer, add a relationship to the Hub, create a dataflow set, add the source model object and map the foreign-key terms and the descriptive terms.

Historization

The loader inserts a new version of a key when its row hash BG_RowHash differs from the current version. The new version starts at the load timestamp, and the previous version ends there. The current version ends at End of Universe, 9999-12-31 by default. An unchanged row adds no version, and the loader never deletes or updates rows.

• The row hash covers the descriptive terms. Business keys, foreign keys, Default Terms and the terms listed in Excluded from Delta Detection are not part of it. See BG_RowHash.
• With Persist Validity false, the result view calculates BG_ValidToTimestamp from the next version. With true, the table stores it and the loader closes the previous version.
• With a Version Valid From Term, the Satellite loads the versions that the source delivers. See Configure a multi-version load.

See Change detection and historization.

Properties

• Implementation Type: Permanent only.
• Foreign Key Mode: whether the table gets a foreign key to the Hub table. With Create Disabled, the default, it is created and disabled.
• Load Caching: empty (default) or Hashing, which stores the hashing view in a table before the loader runs.
• Increment Management Type: Auto (default) or User, for an incremental load with BG_IncrementalFilter. See Configure an incremental load.
• Custom Singleton Values: values of the unknown-member row.
• Excluded from Delta Detection: terms that are stored but do not start a new version.
• Version Valid From Term, per dataflow model object.
• Deduplication Method and Sort Order within Partition, per dataflow.
• Use Embryo Loader, on the relationship: inserts Hub keys that the Hub does not hold yet.

The project properties Persist Validity and Create Result Views also apply.

Default Terms

• Hub_HK: the key of the Hub row, calculated from the foreign-key terms.
• BG_ValidFromTimestamp: start of the version. With Hub_HK it forms the primary key.
• BG_ValidToTimestamp: end of the version; a table column only with Persist Validity.
• BG_RowHash: hash of the descriptive terms, compared with the current version.
• BG_LoadTimestamp and BG_SourceSystem: the load that inserted the row and its source system, empty unless you map it.
• BG_IncrementalFilter: source term for an incremental load; not stored in the table.
• BG_DataQuality_ID, BG_ErrorCount and BG_ErrorDescription: hidden terms of the data quality objects.

Generated objects

These are the names on Microsoft SQL Server for the Satellite load_customer_sat with one dataflow:

• Loaders are stored procedures; the Satellite table, the hashing table and the increment table are tables; all other objects are views.
• The deduplication view exists only with a Deduplication Method other than None.
• The versioning and row-condensing views exist only with a Version Valid From Term.
• The hashing table and hashing loader exist only with Load Caching Hashing.
• The increment table exists only with an incremental load, that is, when a dataflow maps BG_IncrementalFilter; the increment source view only with Increment Management Type Auto.
• The embryo loader exists only when Use Embryo Loader is true on the relationship. It runs before the loader.
• The result view exists only with Create Result Views. Without it, Persist Validity must be true; otherwise validation reports an error.
• With several dataflows, all objects except the table and the result view exist once per dataflow, with the dataflow name in their names.
• The table script inserts the unknown-member row: a Hub_HK of zeros, text terms Unknown and dates 1900-01-01. The result view hides it.

With the default settings, a load runs this chain:

sources -> _Source -> _Hashing -> _Delta -> _Loader
_Loader -> RDV_SAT_load_customer_sat -> _Result
_Result -> _Delta (current versions)

The delta view keeps the source rows whose Hub_HK and BG_RowHash do not match a current version in the result view. The loader inserts them with the load timestamp as BG_ValidFromTimestamp. The optional objects sit in this order: _Deduplication and _Versioning before _Hashing, _HashingLoader and _HashingTable or _RowCondensing after it. For an incremental load, the loader first writes the new increment from _IncrementSource to _Increment, and _Source reads only the rows of that increment.

Example

The Satellite load_customer_sat on Microsoft SQL Server reads the Stage CUSTOMER and has a relationship to the Hub load_customer_hub. Its descriptive terms are CUSTOMER, CUSTOMER_TYPE and CUSTOMER_SINCE. Persist Validity is false, the default on Microsoft SQL Server. The loads deliver these rows:

• Load 1 on 2026-10-28 08:00: customer 1 Contoso Ltd and customer 2 Fabrikam AG, both of type Business.
• Load 2 on 2026-10-29 08:00: customer 1 renamed to Contoso Group, customer 2 unchanged, and the new customer 3 Northwind of type Private.
• Load 3 on 2026-10-30 08:00: the same rows as load 2.

Check the result

Query the result view with the business key from the Hub, here in the schema rv:

SELECT h.CUSTOMER_ID, s.CUSTOMER, s.CUSTOMER_TYPE,
       s.BG_ValidFromTimestamp, s.BG_ValidToTimestamp, s.BG_RowHash
FROM rv.RDV_SAT_load_customer_sat_Result AS s
JOIN rv.RDV_HUB_load_customer_hub_Result AS h ON h.Hub_HK = s.Hub_HK
ORDER BY h.CUSTOMER_ID, s.BG_ValidFromTimestamp;

This is the result after load 3, split into two blocks with the column names shortened and BG_RowHash cut to its first four bytes:

CUSTOMER_ID  CUSTOMER       CUSTOMER_TYPE  ValidFrom
1            Contoso Ltd    Business       2026-10-28 08:00
1            Contoso Group  Business       2026-10-29 08:00
2            Fabrikam AG    Business       2026-10-28 08:00
3            Northwind      Private        2026-10-29 08:00

CUSTOMER_ID  ValidFrom         ValidTo           BG_RowHash
1            2026-10-28 08:00  2026-10-29 08:00  0x73D17654
1            2026-10-29 08:00  9999-12-31 00:00  0xB82C0ADA
2            2026-10-28 08:00  9999-12-31 00:00  0xAD1F7FE8
3            2026-10-29 08:00  9999-12-31 00:00  0xCF66C10A

• The new name of customer 1 changed the row hash, so load 2 started a second version and ended the first one.
• Customer 2 kept its row hash and has one version.
• Load 3 inserted no row.
• The table has no BG_ValidToTimestamp column; the result view calculates it.

Platform differences

• Persist Validity is true by default on Snowflake, Snowflake dbt, Databricks, Databricks dbt, Fabric Lakehouse and Fabric Warehouse, and false on Microsoft SQL Server and Oracle.
• Snowflake: names are in capitals, and the loader is a stored procedure. The load control task LC_RDV_SAT_<model object name>_TASK calls it. The dataflow properties Use Stream and Warehouse Placeholder Variable Name apply.
• Databricks and Fabric Lakehouse: table and view names are in lowercase, and the loader is the notebook RDV_SAT_<model object name>_Loader. The properties File Format, Optimization Method, Optimization Method Columns and Use Sequential Dataflow Execution apply. Fabric Lakehouse allows only Foreign Key Mode None.
• Databricks dbt and Snowflake dbt: the Satellite becomes the dbt models rdv_sat_<model object name>_source and rdv_sat_<model object name>. The model rdv_sat_<model object name>_result exists only when Create Result Views is true; the default on dbt is false. Load Caching, Increment Management Type and Use Embryo Loader are not available.
• Fabric Warehouse: the same objects as on Microsoft SQL Server, deployed by notebooks.
• Oracle: names are in capitals, and the loader is a PL/SQL package. Hash Group Size splits the input of BG_RowHash into groups of terms: with the value 1, each term is hashed on its own and the results are hashed together. Partition Clause adds its text to the CREATE TABLE statement. Table Compression, the tablespaces and the statistics properties also apply.
• Foreign Key Mode Create Enforced exists only on Microsoft SQL Server and Oracle.

Limitations

• A Satellite has exactly one relationship to a Hub. Business keys on a Satellite raise a validation warning.
• With a Version Valid From Term, a Satellite allows one dataflow, one dataflow set and no aggregation.
• A dataflow delivers at most one row per Hub key and load. Two rows with different values for a new key make the loader fail with a primary key violation. For a key that is already stored, a row equal to its current version adds nothing, and the other row is stored as a new version.

Release differences

• Generator 2.2: Increment Management Type, Use Embryo Loader and Persist Validity are available.
• Generator 2.3: Custom Singleton Values is available, and Hash Group Size on Oracle.
• Generator 2.4: Excluded from Delta Detection is available.

Related articles

• Previous: Hub
• Next: Configure a multi-version load, Configure an incremental load
• Reference: BG_RowHash, BG_ValidFromTimestamp, BG_ValidToTimestamp, Excluded from Delta Detection (Model Object), Version Valid From Term (Dataflow Model Object), Persist Validity (Project), Create Result Views (Project), Custom Singleton Values (Model Object), Hash Group Size (Model Object), Foreign Key Mode (Model Object)
• See also: Change detection and historization, How biGENIUS-X builds hash values, Embryo Loader, Link Satellite, Create a Model Object with the wizard