undefined

If usage sorting isn't available (OSS), filter by tier-1 tags or a specific domain instead to find the most important tables.

Then for each table, create a freshness + volume smart monitor pair (see Step 6 canonical examples). This gives broad anomaly coverage with minimal setup. Once the user sees value, they can add targeted user-defined checks (field nulls, schema drift, custom SQL) on specific tables.

---

undefined

Present the candidate list and confirm scope before proceeding to assertion creation. For large result sets, paginate and ask the user to confirm the batch.

**Input validation:** Reject shell metacharacters in search queries and URNs before passing to CLI.

undefined

Or via GraphQL (using `entities` field, NOT `assets` — that field does not exist):

```bash
cat > /tmp/dp-query.graphql << 'EOF'
query {
  dataProduct(urn: "urn:li:dataProduct:<ID>") {
    properties { name }
    entities(input: { query: "*" }) {
      total
      searchResults {
        entity {
          urn type
          ... on Dataset {
            properties { name }
            platform { name }
            health { type status message }
          }
        }
      }
    }
  }
}
EOF
datahub -C skill=datahub-quality graphql --query /tmp/dp-query.graphql --format json
rm /tmp/dp-query.graphql

datahub -C skill=datahub-quality search "*" \
  --where "hasActiveIncidents = true OR hasFailingAssertions = true" \
  --projection "urn type
    ... on Dataset { properties { name } platform { name }
      health { type status message
        activeIncidentHealthDetails { count latestIncidentTitle }
        latestAssertionStatusByType { type status total }
      }
    }" \
  --format json --limit 20

datahub -C skill=datahub-quality search "*" \
  --where "entity_type = dataset AND platform = snowflake AND hasFailingAssertions = true" \
  --format json --limit 20

datahub -C skill=datahub-quality graphql --query '
query {
  dataset(urn: "<DATASET_URN>") {
    properties { name }
    health { type status message
      activeIncidentHealthDetails { count latestIncidentTitle }
      latestAssertionStatusByType { type status total }
    }
    assertions(start: 0, count: 50) {
      total
      assertions {
        urn
        info { type description source { type } }
        runEvents(limit: 1) {
          runEvents { status result { type } timestampMillis }
        }
      }
    }
    incidents(state: ACTIVE, start: 0, count: 20) {
      total
      incidents {
        urn incidentType title priority
        incidentStatus { state stage message }
        source { type }
        created { time actor }
      }
    }
  }
}' --format json

datahub -C skill=datahub-quality graphql --query '
query {
  assertion(urn: "<ASSERTION_URN>") {
    info { type description }
    runEvents(limit: 10) {
      total failed succeeded
      runEvents {
        timestampMillis status
        result { type nativeResults { key value } }
      }
    }
  }
}' --format json

undefined

---

evaluationParameters: {
  sourceType: FIELD_VALUE
  field: { path: "updated_at", type: "TIMESTAMP", nativeType: "TIMESTAMP_NTZ" }
}

actions: {
  onFailure: [{ type: RAISE_INCIDENT }]
  onSuccess: [{ type: RESOLVE_INCIDENT }]
}

undefined

---

datahub -C skill=datahub-quality graphql --query 'mutation {
  upsertDatasetFreshnessAssertionMonitor(input: {
    entityUrn: "<DATASET_URN>"
    schedule: { type: FIXED_INTERVAL, fixedInterval: { unit: DAY, multiple: 1 } }
    evaluationSchedule: { cron: "0 9 * * *", timezone: "UTC" }
    evaluationParameters: { sourceType: INFORMATION_SCHEMA }
    mode: ACTIVE
    actions: { onFailure: [{ type: RAISE_INCIDENT }], onSuccess: [{ type: RESOLVE_INCIDENT }] }
  }) { urn }
}' --format json

datahub -C skill=datahub-quality graphql --query 'mutation {
  createFieldAssertion(input: {
    entityUrn: "<DATASET_URN>"
    type: FIELD_VALUES
    fieldValuesAssertion: {
      field: { path: "email", type: "STRING", nativeType: "VARCHAR" }
      operator: NOT_NULL
      excludeNulls: false
      failThreshold: { type: COUNT, value: 0 }
    }
  }) { urn }
}' --format json

datahub -C skill=datahub-quality graphql --query 'mutation {
  upsertDatasetFreshnessAssertionMonitor(input: {
    entityUrn: "<DATASET_URN>"
    inferWithAI: true
    evaluationSchedule: { cron: "0 9 * * *", timezone: "UTC" }
    evaluationParameters: { sourceType: INFORMATION_SCHEMA }
    mode: ACTIVE
  }) { urn }
}' --format json

datahub -C skill=datahub-quality graphql --query 'mutation {
  upsertDatasetVolumeAssertionMonitor(input: {
    entityUrn: "<DATASET_URN>"
    type: ROW_COUNT_TOTAL
    inferWithAI: true
    rowCountTotal: { operator: GREATER_THAN, parameters: { value: { value: "0", type: NUMBER } } }
    evaluationSchedule: { cron: "0 9 * * *", timezone: "UTC" }
    evaluationParameters: { sourceType: QUERY }
    mode: ACTIVE
  }) { urn }
}' --format json

datahub -C skill=datahub-quality graphql --query 'mutation {
  upsertDatasetFieldAssertionMonitor(input: {
    entityUrn: "<DATASET_URN>"
    type: FIELD_METRIC
    inferWithAI: true
    evaluationSchedule: { cron: "0 9 * * *", timezone: "UTC" }
    evaluationParameters: { sourceType: ALL_ROWS_QUERY }
    mode: ACTIVE
  }) { urn }
}' --format json

datahub -C skill=datahub-quality graphql --query 'mutation {
  runAssertionsForAsset(urn: "<DATASET_URN>") {
    passingCount failingCount errorCount
    results { assertion { urn info { type } } result { type } }
  }
}' --format json

undefined

**Raise an incident:**

```bash
datahub -C skill=datahub-quality graphql --query 'mutation {
  raiseIncident(input: {
    type: OPERATIONAL
    title: "Data pipeline delayed"
    description: "Nightly ETL has not completed in 6 hours"
    resourceUrn: "<DATASET_URN>"
    priority: HIGH
    status: { state: ACTIVE, stage: TRIAGE }
  })
}' --format json

datahub -C skill=datahub-quality graphql --query 'mutation {
  updateIncidentStatus(urn: "<INCIDENT_URN>", input: {
    state: RESOLVED, stage: FIXED, message: "Pipeline backfilled"
  })
}' --format json

datahub -C skill=datahub-quality graphql --query 'mutation {
  createSubscription(input: {
    entityUrn: "<DATASET_URN>"
    subscriptionTypes: [ENTITY_CHANGE]
    entityChangeTypes: [{ entityChangeType: ASSERTION_FAILED }, { entityChangeType: ASSERTION_ERROR }]
    notificationConfig: {
      notificationSettings: {
        sinkTypes: [SLACK]
        slackSettings: { channels: ["#data-quality-alerts"] }
      }
    }
  }) { subscriptionUrn }
}' --format json