Skip to main content
Version: Next

CorpUser

CorpUser represents an individual user (or account) in the enterprise. These entities serve as the identity layer within DataHub, representing people who interact with data assets, own resources, belong to groups, and have roles and permissions within the organization. CorpUsers can represent LDAP users, Active Directory accounts, SSO identities, or native DataHub users.

Identity​

CorpUsers are uniquely identified by a single piece of information:

  • Username: A unique identifier for the user within the organization. This is typically sourced from the corporate identity provider (LDAP, Active Directory, etc.) or can be an email address for native DataHub users.

The URN structure for CorpUser is:

urn:li:corpuser:<username>

Examples​

urn:li:corpuser:jdoe
urn:li:corpuser:john.doe@company.com
urn:li:corpuser:jdoe@company.com

The username is stored in the corpUserKey aspect, which is the identity aspect for this entity. The username field is marked as searchable and enables autocomplete functionality in the DataHub UI.

Username Conventions​

The username can follow various conventions depending on your organization's identity provider:

  • LDAP/Active Directory usernames: jdoe, john.doe, john_doe
  • Email addresses: jdoe@company.com, john.doe@company.com
  • SSO identities: Depends on your SSO provider's username format
  • Native DataHub users: Typically email addresses

It's important to maintain consistency in username formats across your DataHub deployment to ensure proper identity resolution and relationship tracking.

Important Capabilities​

Profile Information​

The core profile information about a user is stored in the corpUserInfo aspect. This is typically populated automatically by ingestion connectors from identity providers like LDAP, Active Directory, Azure AD, Okta, or other SSO systems.

Key Fields:

  • displayName: The user's name as it should appear in the UI
  • email: Email address for contacting the user
  • title: Job title (e.g., "Senior Data Engineer")
  • firstName and lastName: Components of the user's name
  • fullName: Full name typically formatted as "firstName lastName"
  • managerUrn: URN reference to the user's direct manager (another CorpUser)
  • departmentId and departmentName: Organizational department information
  • countryCode: Two-letter country code (e.g., "US", "UK")
  • active: Whether the user account is active (deprecated in favor of corpUserStatus)
  • system: Whether this is a system/service account rather than a human user

The managerUrn field creates a relationship between users, enabling organizational hierarchy visualization in DataHub.

Editable User Information​

The corpUserEditableInfo aspect contains information that users can modify through the DataHub UI, allowing users to enrich their profiles beyond what's provided by the identity provider.

Key Fields:

  • aboutMe: A personal description or bio
  • displayName: User-specified display name (overrides the one from corpUserInfo)
  • title: User-specified title (overrides the one from corpUserInfo)
  • teams: List of team names the user belongs to (e.g., ["Data Platform", "Analytics"])
  • skills: List of skills the user possesses (e.g., ["Python", "SQL", "Machine Learning"])
  • pictureLink: URL to a profile picture
  • slack: Slack handle for communication
  • phone: Contact phone number
  • email: Contact email (can differ from the system email)
  • platforms: URNs of data platforms the user commonly works with
  • persona: URN of the user's DataHub persona (role-based persona like "Data Analyst")

User Status​

The corpUserStatus aspect tracks the current status of the user account, replacing the deprecated active field in corpUserInfo.

Key Fields:

  • status: Current status of the user (e.g., "ACTIVE", "SUSPENDED", "PROVISIONED")
  • lastModified: Audit stamp with information about who last modified the status and when

This aspect provides more granular control over user account states compared to the simple boolean active field.

Group Membership​

Users can be members of groups through two different aspects:

groupMembership: Represents membership in CorpGroups that may be managed within DataHub or synchronized from external systems. This creates IsMemberOfGroup relationships.

nativeGroupMembership: Represents membership in groups that are native to an external identity provider (like Active Directory groups). This creates IsMemberOfNativeGroup relationships.

Both aspects store arrays of group URNs, allowing users to belong to multiple groups simultaneously.

Role Membership​

The roleMembership aspect associates users with DataHub roles, which define their permissions and access within the platform.

Key Fields:

  • roles: Array of DataHubRole URNs that the user is assigned to

This creates IsMemberOfRole relationships and is fundamental to DataHub's role-based access control (RBAC) system.

Authentication Credentials​

The corpUserCredentials aspect stores authentication information for native DataHub users (users created directly in DataHub rather than synchronized from an external identity provider).

Key Fields:

  • salt: Salt used for password hashing
  • hashedPassword: The hashed password
  • passwordResetToken: Optional token for password reset operations
  • passwordResetTokenExpirationTimeMillis: When the reset token expires

This aspect is only used for native authentication and is not populated for users authenticated through SSO or LDAP.

User Settings​

The corpUserSettings aspect stores user-specific preferences for the DataHub UI and features.

Key Fields:

  • appearance: Settings controlling the look and feel of the DataHub UI
    • showSimplifiedHomepage: Whether to show a simplified homepage with only datasets, charts, and dashboards
    • showThemeV2: Whether to use the V2 theme
  • views: Settings for the Views feature
    • defaultView: The user's default DataHub view
  • notificationSettings: Preferences for notifications
  • homePage: Settings for the home page experience
    • pageTemplate: The user's default page template
    • dismissedAnnouncementUrns: List of announcements the user has dismissed

Origin​

The origin aspect tracks where the user entity originated from, distinguishing between native DataHub users and those synchronized from external systems.

Key Fields:

  • type: Either "NATIVE" or "EXTERNAL"
  • externalType: Name of the external identity provider (e.g., "AzureAD", "Okta", "LDAP")

This information is useful for understanding the source of truth for user data and managing synchronization processes.

Slack Integration​

The slackUserInfo aspect contains detailed information about a user's Slack identity, enabling rich Slack integration features within DataHub.

Key Fields:

  • slackInstance: URN of the Slack workspace
  • id: Unique Slack member ID
  • name: Slack username
  • realName: Real name in Slack
  • displayName: Display name in Slack
  • email: Email associated with the Slack account
  • teamId: Slack team/workspace ID
  • isDeleted, isAdmin, isOwner, isPrimaryOwner, isBot: Account status flags
  • timezone and timezoneOffset: User's timezone information
  • title: Job title from Slack
  • phone: Phone number from Slack
  • profilePictureUrl: URL to Slack profile picture
  • statusText and statusEmoji: Current Slack status

Tags, Structured Properties, and Forms​

Like other DataHub entities, CorpUsers support:

  • globalTags: Tags attached to the user entity for categorization
  • structuredProperties: Custom properties defined by your organization's data model
  • forms: Forms that can be attached to users for collecting structured information
  • status: Generic status aspect for soft-deletion

These common aspects enable flexible metadata management and integration with DataHub's broader metadata framework.

Code Examples​

Creating a CorpUser​

The simplest way to create a CorpUser is using the high-level Python SDK:

Python SDK: Create a basic user
# Inlined from /metadata-ingestion/examples/library/corpuser_create_basic.py
# metadata-ingestion/examples/library/corpuser_create_basic.py
import logging
import os

from datahub.api.entities.corpuser.corpuser import CorpUser
from datahub.ingestion.graph.client import DataHubGraph, DataHubGraphConfig

log = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

# Create a basic user with essential information
user = CorpUser(
    id="jdoe",
    display_name="John Doe",
    email="jdoe@company.com",
    title="Senior Data Engineer",
    first_name="John",
    last_name="Doe",
    full_name="John Doe",
    department_name="Data Engineering",
    country_code="US",
)

# Create graph client
gms_server = os.getenv("DATAHUB_GMS_URL", "http://localhost:8080")
token = os.getenv("DATAHUB_GMS_TOKEN")
datahub_graph = DataHubGraph(DataHubGraphConfig(server=gms_server, token=token))

# Emit the user entity
for event in user.generate_mcp():
    datahub_graph.emit(event)

log.info(f"Created user {user.urn}")

Creating a CorpUser with Group Memberships​

Users are often members of groups. Here's how to create a user and assign them to groups:

Python SDK: Create user with group memberships
# Inlined from /metadata-ingestion/examples/library/corpuser_create_with_groups.py
# metadata-ingestion/examples/library/corpuser_create_with_groups.py
import logging

from datahub.api.entities.corpuser.corpuser import CorpUser
from datahub.ingestion.graph.client import DataHubGraph, DataHubGraphConfig

log = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

# Create a user with group memberships
user = CorpUser(
    id="jsmith",
    display_name="Jane Smith",
    email="jsmith@company.com",
    title="Data Analyst",
    first_name="Jane",
    last_name="Smith",
    full_name="Jane Smith",
    department_name="Analytics",
    country_code="US",
    groups=["data-engineering", "analytics-team"],
)

# Create graph client
datahub_graph = DataHubGraph(DataHubGraphConfig(server="http://localhost:8080"))

# Emit the user entity with group memberships
for event in user.generate_mcp():
    datahub_graph.emit(event)

log.info(f"Created user {user.urn} with group memberships")

Updating User Profile Information​

To update editable profile information for an existing user:

Python SDK: Update user profile
# Inlined from /metadata-ingestion/examples/library/corpuser_update_profile.py
# metadata-ingestion/examples/library/corpuser_update_profile.py
import logging

from datahub.api.entities.corpuser.corpuser import CorpUser, CorpUserGenerationConfig
from datahub.ingestion.graph.client import DataHubGraph, DataHubGraphConfig

log = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

# Update a user's editable profile information
user = CorpUser(
    id="jdoe",
    email="jdoe@company.com",
    description="Passionate about data quality and building reliable data pipelines. "
    "10+ years of experience in data engineering.",
    slack="@jdoe",
    phone="+1-555-0123",
    picture_link="https://company.com/photos/jdoe.jpg",
)

# Create graph client
datahub_graph = DataHubGraph(DataHubGraphConfig(server="http://localhost:8080"))

# Emit with override_editable=True to update editable fields
for event in user.generate_mcp(
    generation_config=CorpUserGenerationConfig(override_editable=True)
):
    datahub_graph.emit(event)

log.info(f"Updated profile for user {user.urn}")

Adding Tags to a User​

Users can be tagged for categorization and discovery:

Python SDK: Add tags to a user
# Inlined from /metadata-ingestion/examples/library/corpuser_add_tag.py
# metadata-ingestion/examples/library/corpuser_add_tag.py
import logging

from datahub.emitter.mce_builder import make_tag_urn, make_user_urn
from datahub.emitter.mcp import MetadataChangeProposalWrapper
from datahub.ingestion.graph.client import DataHubGraph, DataHubGraphConfig
from datahub.metadata.schema_classes import GlobalTagsClass, TagAssociationClass

log = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

# User to add tag to
user_urn = make_user_urn("jdoe")

# Tag to add
tag_urn = make_tag_urn("DataEngineering")

# Create graph client
datahub_graph = DataHubGraph(DataHubGraphConfig(server="http://localhost:8080"))

# Read current tags
current_tags = datahub_graph.get_aspect(
    entity_urn=user_urn, aspect_type=GlobalTagsClass
)

# Initialize tags if they don't exist
if current_tags is None:
    current_tags = GlobalTagsClass(tags=[])

# Check if tag already exists
tag_exists = any(tag.tag == tag_urn for tag in current_tags.tags)

if not tag_exists:
    # Add the new tag
    new_tag = TagAssociationClass(tag=tag_urn)
    current_tags.tags.append(new_tag)

    # Create MCP to update the tags
    mcp = MetadataChangeProposalWrapper(
        entityUrn=user_urn,
        aspect=current_tags,
    )

    # Emit the change
    datahub_graph.emit(mcp)
    log.info(f"Added tag {tag_urn} to user {user_urn}")
else:
    log.info(f"Tag {tag_urn} already exists on user {user_urn}")

Querying Users via REST API​

You can fetch user information using the REST API:

REST API: Get user information
# Get a user by URN
curl -X GET "http://localhost:8080/entities/urn%3Ali%3Acorpuser%3Ajdoe" \
  -H "Authorization: Bearer <your-access-token>"

# Get specific aspects of a user
curl -X GET "http://localhost:8080/aspects/urn%3Ali%3Acorpuser%3Ajdoe?aspect=corpUserInfo&aspect=corpUserEditableInfo&aspect=groupMembership" \
  -H "Authorization: Bearer <your-access-token>"

Searching for Users​

You can search for users using the GraphQL API or search API:

GraphQL: Search for users
query searchUsers {
  search(input: { type: CORP_USER, query: "john", start: 0, count: 10 }) {
    start
    count
    total
    searchResults {
      entity {
        ... on CorpUser {
          urn
          username
          properties {
            displayName
            email
            title
            fullName
          }
          editableProperties {
            aboutMe
            teams
            skills
            slack
          }
        }
      }
    }
  }
}

Integration Points​

Relationships with Other Entities​

CorpUsers have several important relationships with other DataHub entities:

Ownership Relationships:

  • CorpUsers can be owners of datasets, dashboards, charts, data flows, and virtually any other entity in DataHub
  • The ownership relationship includes the owner type (e.g., DATAOWNER, TECHNICAL_OWNER, BUSINESS_OWNER)

Group Relationships:

  • Users belong to CorpGroups through IsMemberOfGroup relationships
  • Groups can also be owners of assets, providing inherited ownership

Role Relationships:

  • Users are assigned to DataHub roles through IsMemberOfRole relationships
  • Roles define permissions and access levels within DataHub

Organizational Hierarchy:

  • The managerUrn field in corpUserInfo creates ReportsTo relationships
  • This enables visualization of organizational structure and reporting chains

Platform Usage:

  • The platforms field in corpUserEditableInfo creates IsUserOf relationships
  • This helps identify which platforms users commonly work with

Persona Assignment:

  • Users can be assigned to DataHub personas through the persona field
  • This helps categorize users by their role and customize their experience

Identity Provider Integration​

CorpUsers are typically synchronized from external identity providers:

LDAP/Active Directory:

  • Most organizations use LDAP connectors to automatically synchronize user information
  • The username typically corresponds to the LDAP uid or sAMAccountName
  • Profile information is populated from LDAP attributes

SSO Providers (Okta, Azure AD, etc.):

  • SSO integrations can provision users automatically on first login
  • User attributes from the SSO provider populate the corpUserInfo aspect
  • The origin aspect tracks the SSO provider as the source

Native DataHub Users:

  • Users can be created directly in DataHub for testing or small deployments
  • These users have credentials stored in the corpUserCredentials aspect
  • They are marked with origin.type = NATIVE

Authentication and Authorization​

CorpUsers are central to DataHub's security model:

Authentication:

  • Native users authenticate with username/password
  • SSO users authenticate through their identity provider
  • API tokens can be associated with users for programmatic access

Authorization (RBAC):

  • Users are assigned to roles through the roleMembership aspect
  • Roles define what actions users can perform
  • Policies can reference users or groups to grant/restrict access

Metadata Access:

  • Users can only see metadata they have permission to view
  • Ownership and group membership influence what users can edit
  • Policies can be user-specific or group-based

Notable Exceptions​

System Users​

CorpUsers can represent both human users and system/service accounts. The system field in corpUserInfo distinguishes between these:

  • Human Users (system: false): Actual people who interact with DataHub
  • System Accounts (system: true): Service accounts, automated processes, or system-level operations

System users should be marked appropriately to distinguish them in reports, ownership lists, and access reviews.

Deprecated Active Field​

The active field in corpUserInfo is deprecated. Use the corpUserStatus aspect instead, which provides:

  • More granular status options beyond just active/inactive
  • Audit information about status changes
  • Better support for provisioning workflows

When working with users, prefer checking corpUserStatus.status over corpUserInfo.active.

Username Immutability​

The username (in corpUserKey) is immutable once a user is created. If a user's username changes in the source system:

  • A new CorpUser entity must be created with the new username
  • Ownership and other relationships need to be migrated to the new entity
  • The old user can be soft-deleted using the status aspect

Plan your username strategy carefully to avoid frequent username changes.

Display Name Precedence​

Display names can appear in multiple aspects with this precedence:

  1. corpUserEditableInfo.displayName (user-specified, highest priority)
  2. corpUserInfo.displayName (from identity provider)
  3. corpUserInfo.fullName (fallback if no display name is set)

The DataHub UI resolves these in order, showing the most specific value available.

Technical Reference Guide​

The sections above provide an overview of how to use this entity. The following sections provide detailed technical information about how metadata is stored and represented in DataHub.

Aspects are the individual pieces of metadata that can be attached to an entity. Each aspect contains specific information (like ownership, tags, or properties) and is stored as a separate record, allowing for flexible and incremental metadata updates.

Relationships show how this entity connects to other entities in the metadata graph. These connections are derived from the fields within each aspect and form the foundation of DataHub's knowledge graph.

Reading the Field Tables​

Each aspect's field table includes an Annotations column that provides additional metadata about how fields are used:

  • ⚠️ Deprecated: This field is deprecated and may be removed in a future version. Check the description for the recommended alternative
  • Searchable: This field is indexed and can be searched in DataHub's search interface
  • Searchable (fieldname): When the field name in parentheses is shown, it indicates the field is indexed under a different name in the search index. For example, dashboardTool is indexed as tool
  • → RelationshipName: This field creates a relationship to another entity. The arrow indicates this field contains a reference (URN) to another entity, and the name indicates the type of relationship (e.g., → Contains, → OwnedBy)

Fields with complex types (like Edge, AuditStamp) link to their definitions in the Common Types section below.

Aspects​

corpUserKey​

Key for a CorpUser

FieldTypeRequiredDescriptionAnnotations
usernamestring✓The name of the AD/LDAP user.Searchable (ldap)

corpUserInfo​

Linkedin corp user information

FieldTypeRequiredDescriptionAnnotations
customPropertiesmap✓Custom property bag.Searchable
activeboolean✓Deprecated! Use CorpUserStatus instead. Whether the corpUser is active, ref: https://iwww.corp.li...Searchable
displayNamestringdisplayName of this user , e.g. Hang Zhang(DataHQ)Searchable
emailstringemail address of this userSearchable
titlestringtitle of this userSearchable
managerUrnstringdirect manager of this userSearchable (managerLdap), → ReportsTo
departmentIdlongdepartment id this user belong to
departmentNamestringdepartment name this user belong to
firstNamestringfirst name of this user
lastNamestringlast name of this user
fullNamestringCommon name of this user, format is firstName + lastName (split by a whitespace)Searchable
countryCodestringtwo uppercase letters country code. e.g. US
systembooleanWhether the corpUser is a system user.Searchable

corpUserEditableInfo​

Linkedin corp user information that can be edited from UI

FieldTypeRequiredDescriptionAnnotations
aboutMestringAbout me section of the user
teamsstring[]✓Teams that the user belongs to e.g. MetadataSearchable
skillsstring[]✓Skills that the user possesses e.g. Machine LearningSearchable
pictureLinkstring✓A URL which points to a picture which user wants to set as a profile photo
displayNamestringDataHub-native display nameSearchable
titlestringDataHub-native Title, e.g. 'Software Engineer'
platformsstring[]The platforms that the user commonly works with→ IsUserOf
personastringThe user's persona type, based on their role→ IsPersona
slackstringSlack handle for the user
phonestringPhone number to contact the user
emailstringEmail address to contact the user
informationSourcesstring[]Information sources that have been used to populate this CorpUserEditableInfo. These include plat...

corpUserStatus​

The status of the user, e.g. provisioned, active, suspended, etc.

FieldTypeRequiredDescriptionAnnotations
statusstring✓Status of the user, e.g. PROVISIONED / ACTIVE / SUSPENDEDSearchable
lastModifiedAuditStamp✓Audit stamp containing who last modified the status and when.Searchable

groupMembership​

Carries information about the CorpGroups a user is in.

FieldTypeRequiredDescriptionAnnotations
groupsstring[]✓→ IsMemberOfGroup

globalTags​

Tag aspect used for applying tags to an entity

FieldTypeRequiredDescriptionAnnotations
tagsTagAssociation[]✓Tags associated with a given entitySearchable, → TaggedWith

status​

The lifecycle status metadata of an entity, e.g. dataset, metric, feature, etc. This aspect is used to represent soft deletes conventionally.

FieldTypeRequiredDescriptionAnnotations
removedboolean✓Whether the entity has been removed (soft-deleted).Searchable

corpUserCredentials​

Corp user credentials

FieldTypeRequiredDescriptionAnnotations
saltstring✓Salt used to hash password
hashedPasswordstring✓Hashed password generated by concatenating salt and password, then hashing
passwordResetTokenstringOptional token needed to reset a user's password. Can only be set by the admin.
passwordResetTokenExpirationTimeMillislongWhen the password reset token expires.

nativeGroupMembership​

Carries information about the native CorpGroups a user is in.

FieldTypeRequiredDescriptionAnnotations
nativeGroupsstring[]✓→ IsMemberOfNativeGroup

corpUserSettings​

Settings that a user can customize through the datahub ui

FieldTypeRequiredDescriptionAnnotations
appearanceCorpUserAppearanceSettings✓Settings for a user around the appearance of their DataHub U
viewsCorpUserViewsSettingsUser preferences for the Views feature.
notificationSettingsNotificationSettingsNotification settings for a user
homePageCorpUserHomePageSettingsSettings related to the home page for a user

origin​

Carries information about where an entity originated from.

FieldTypeRequiredDescriptionAnnotations
typeOriginType✓Where an entity originated from. Either NATIVE or EXTERNAL.
externalTypestringOnly populated if type is EXTERNAL. The externalType of the entity, such as the name of the ident...

roleMembership​

Carries information about which roles a user or group is assigned to.

FieldTypeRequiredDescriptionAnnotations
rolesstring[]✓→ IsMemberOfRole

structuredProperties​

Properties about an entity governed by StructuredPropertyDefinition

FieldTypeRequiredDescriptionAnnotations
propertiesStructuredPropertyValueAssignment[]✓Custom property bag.

forms​

Forms that are assigned to this entity to be filled out

FieldTypeRequiredDescriptionAnnotations
incompleteFormsFormAssociation[]✓All incomplete forms assigned to the entity.Searchable
completedFormsFormAssociation[]✓All complete forms assigned to the entity.Searchable
verificationsFormVerificationAssociation[]✓Verifications that have been applied to the entity via completed forms.Searchable

testResults​

Information about a Test Result

FieldTypeRequiredDescriptionAnnotations
failingTestResult[]✓Results that are failingSearchable, → IsFailing
passingTestResult[]✓Results that are passingSearchable, → IsPassing

subTypes​

Sub Types. Use this aspect to specialize a generic Entity e.g. Making a Dataset also be a View or also be a LookerExplore

FieldTypeRequiredDescriptionAnnotations
typeNamesstring[]✓The names of the specific types.Searchable

slackUserInfo​

Information about a Slack user.

FieldTypeRequiredDescriptionAnnotations
slackInstancestring✓The dataplatform instance that this Slack member belongs to.→ PartOfSlackWorkspace
idstring✓The unique identifier for the Slack member.
namestring✓The username of the Slack member.
realNamestring✓The real name of the Slack member.
displayNamestring✓The display name of the Slack member.
emailstringThe email associated with the Slack member.
teamIdstring✓The ID associated with the Slack team.
isDeletedboolean✓Whether the member is deleted or not.
isAdminboolean✓Whether the member is an admin.
isOwnerboolean✓Whether the member is an owner.
isPrimaryOwnerboolean✓Whether the member is a primary owner.
isBotboolean✓Whether the member is a bot.
timezonestringThe timezone of the Slack member.
timezoneOffsetintThe timezone offset of the Slack member.
titlestringThe title of the Slack member.
phonestringThe phone number of the Slack member.
profilePictureUrlstringThe URL of the member's profile picture.
statusTextstringThe status text of the Slack member.
statusEmojistringThe status emoji of the Slack member.
lastUpdatedSecondslongThe timestamp of when the member was last updated. (in seconds)

Common Types​

These types are used across multiple aspects in this entity.

AuditStamp​

Data captured on a resource/association/sub-resource level giving insight into when that resource/association/sub-resource moved into a particular lifecycle stage, and who acted to move it into that specific lifecycle stage.

Fields:

  • time (long): When did the resource/association/sub-resource move into the specific lifecyc...
  • actor (string): The entity (e.g. a member URN) which will be credited for moving the resource...
  • impersonator (string?): The entity (e.g. a service URN) which performs the change on behalf of the Ac...
  • message (string?): Additional context around how DataHub was informed of the particular change. ...

FormAssociation​

Properties of an applied form.

Fields:

  • urn (string): Urn of the applied form
  • incompletePrompts (FormPromptAssociation[]): A list of prompts that are not yet complete for this form.
  • completedPrompts (FormPromptAssociation[]): A list of prompts that have been completed for this form.

TestResult​

Information about a Test Result

Fields:

  • test (string): The urn of the test
  • type (TestResultType): The type of the result
  • testDefinitionMd5 (string?): The md5 of the test definition that was used to compute this result. See Test...
  • lastComputed (AuditStamp?): The audit stamp of when the result was computed, including the actor who comp...

Relationships​

Self​

These are the relationships to itself, stored in this entity's aspects

  • ReportsTo (via corpUserInfo.managerUrn)

Outgoing​

These are the relationships stored in this entity's aspects

  • IsUserOf

    • DataPlatform via corpUserEditableInfo.platforms

  • IsPersona

    • DataHubPersona via corpUserEditableInfo.persona

  • IsMemberOfGroup

    • CorpGroup via groupMembership.groups

  • TaggedWith

    • Tag via globalTags.tags

  • IsMemberOfNativeGroup

    • CorpGroup via nativeGroupMembership.nativeGroups

  • HasPersonalPageTemplate

    • DataHubPageTemplate via corpUserSettings.homePage.pageTemplate

  • IsMemberOfRole

    • DataHubRole via roleMembership.roles

  • IsFailing

    • Test via testResults.failing

  • IsPassing

    • Test via testResults.passing

  • PartOfSlackWorkspace

    • DataPlatformInstance via slackUserInfo.slackInstance

Incoming​

These are the relationships stored in other entity's aspects

  • Has

    • Role via actors.users.user

  • OwnedBy

    • Dataset via ownership.owners.owner
    • DataJob via ownership.owners.owner
    • DataFlow via ownership.owners.owner
    • DataProcess via ownership.owners.owner
    • Chart via ownership.owners.owner
    • Dashboard via ownership.owners.owner
    • Notebook via ownership.owners.owner

Global Metadata Model​

Global Graph