Jobbsystem table referens

Kommentar

lakeflow schema kallades tidigare workflow. Innehållet i båda schemana är identiskt. Om du vill göra lakeflowschema synlig måste du aktivera den separat.

Den här artikeln är en referens för hur du använder lakeflow system tables för att övervaka jobb i ditt konto. Dessa tables inkluderar poster från alla arbetsytor i ditt konto som har distribuerats i samma molnregion. Om du vill se poster från en annan region måste du visa tables från en arbetsyta som distribuerats i den regionen.

Krav

• system.lakeflow schema måste aktiveras av en kontoadministratör. Se Aktivera system table scheman.
• För att få åtkomst till dessa system tablesmåste användarna antingen:
  • Vara både metaarkivadministratör och kontoadministratör, eller
  • Ha USE och SELECT behörigheter för systemscheman. Se Grant åtkomst till system tables.

Tillgängliga jobb tables

Alla jobbrelaterade system tables finns i system.lakeflowschema. För närvarande är schema värd för fyra tables:

Table	beskrivning	Stöder direktuppspelning	Fri kvarhållningsperiod	Innehåller globala eller regionala data
jobb (offentlig förhandsversion)	Spårar alla jobb som skapats i kontot	Ja	365 dagar	Regional
job_tasks (offentlig förhandsversion)	Spårar alla jobbaktiviteter som körs i kontot	Ja	365 dagar	Regional
job_run_timeline (offentlig förhandsversion)	Spårar jobbkörningar och relaterade metadata	Ja	365 dagar	Regional
job_task_run_timeline (offentlig förhandsversion)	Spårar jobbtaskkörningar och relaterad metadata	Ja	365 dagar	Regional

Detaljerad schema referens

Följande avsnitt innehåller schema referenser för varje av de jobbrelaterade systemen tables.

jobb tableschema

jobs table är en långsamt föränderlig dimension table (SCD2). När en rad ändras genereras en ny rad, vilket logiskt ersätter den föregående.

Table sökväg: system.lakeflow.jobs

Column namn	Datatyp	beskrivning	Anteckningar
account_id	sträng	ID:t för det konto som jobbet tillhör
workspace_id	sträng	ID:t för arbetsytan som det här jobbet tillhör
job_id	sträng	Jobbets ID	Endast unikt inom en enda arbetsyta
name	sträng	Det användarlevererade namnet på jobbet
description	sträng	Beskrivningen av jobbet som användaren har angett	Fylls inte i för rader som genereras före slutet av augusti 2024
creator_id	sträng	ID:t för huvudmannen som skapade aktiviteten
tags	sträng	De anpassade taggar som har angetts av användaren som är associerade med det här jobbet
change_time	timestamp	Den tid då jobbet senast ändrades	Timezone registreras som +00:00 (UTC)
delete_time	timestamp	Den tid då jobbet togs bort av användaren	Timezone registreras som +00:00 (UTC)
run_as	sträng	ID för användaren eller tjänstens huvudnamn vars behörigheter används för jobbkörningen

Exempelfråga

-- Get the most recent version of a job
SELECT
  *,
  ROW_NUMBER() OVER(PARTITION BY workspace_id, job_id ORDER BY change_time DESC) as rn
FROM
  system.lakeflow.jobs QUALIFY rn=1

jobbaktivitet tableschema

Arbetsuppgifter table är av typen långsamt föränderlig dimension table (SCD2). När en rad ändras genereras en ny rad, vilket logiskt ersätter den föregående.

Table sökväg: system.lakeflow.job_tasks

Column namn	Datatyp	beskrivning	Anteckningar
account_id	sträng	ID:t för det konto som jobbet tillhör
workspace_id	sträng	ID:t för arbetsytan som det här jobbet tillhör
job_id	sträng	Jobbets ID	Endast unikt inom en enda arbetsyta
task_key	sträng	Referensnyckeln för en uppgift i ett jobb	Endast unikt inom ett enda jobb
depends_on_keys	matris	Aktivitetsnycklarna för alla överordnade beroenden för den här aktiviteten
change_time	timestamp	Den tid då aktiviteten senast ändrades	Timezone registreras som +00:00 (UTC)
delete_time	timestamp	Den tid då en uppgift togs bort av användaren	Timezone registreras som +00:00 (UTC)

Exempelfråga

-- Get the most recent version of a job task
SELECT
  *,
  ROW_NUMBER() OVER(PARTITION BY workspace_id, job_id ORDER BY change_time DESC) as rn
FROM
  system.lakeflow.job_tasks QUALIFY rn=1

Jobbkörningens tidslinje tableschema

Tidslinjen för jobbkörningen table är oföränderlig och slutförd när den skapas.

Table sökväg: system.lakeflow.job_run_timeline

Column namn	Datatyp	beskrivning	Anteckningar
account_id	sträng	ID:t för det konto som jobbet tillhör
workspace_id	sträng	ID:t för arbetsytan som det här jobbet tillhör
job_id	sträng	Jobbets ID	Den här nyckeln är bara unik på en enda arbetsyta
run_id	sträng	ID:t för jobbkörningen
period_start_time	timestamp	Starttiden för körningen eller för tidsperioden	Timezone-information registreras i värdets slut, där +00:00 representerar UTC
period_end_time	timestamp	Sluttiden för körningen eller för tidsperioden	Timezone-information registreras i slutet av värdet där +00:00 representerar UTC
trigger_type	sträng	Typen av trigger som kan starta en körning	För möjliga values, se utlösartyp values
run_type	sträng	Typ av jobbkörning	Information om möjliga valuesfinns i Kör typ values
run_name	sträng	Det användarinställda körningsnamnet som är associerat med den här jobbkörningen
compute_ids	matris	Matris som innehåller jobbberäknings-ID:t för den överordnade jobbkörningen	Används för att identifiera jobbkluster som används av WORKFLOW_RUN körtyper. Annan beräkningsinformation finns i job_task_run_timelinetable. Fylls inte i för rader som genereras före slutet av augusti 2024
result_state	sträng	Resultatet av jobbkörningen	För möjliga values, se Resultatstatus values
termination_code	sträng	Avslutningskoden för jobbkörningen	Information om möjliga valuesfinns i Avslutningskod values. Fylls inte i för rader som genereras före slutet av augusti 2024
job_parameters	map	Jobbnivån parameters som används i jobbkörningen	De inaktuella notebook_params-inställningarna ingår inte i det här fältet. Fylls inte i för rader som genereras före slutet av augusti 2024

Exempelfråga

-- This query gets the daily job count for a workspace for the last 7 days:
SELECT
  workspace_id,
  COUNT(DISTINCT run_id) as job_count,
  to_date(period_start_time) as date
FROM system.lakeflow.job_run_timeline
WHERE
  period_start_time > CURRENT_TIMESTAMP() - INTERVAL 7 DAYS
GROUP BY ALL

-- This query returns the daily job count for a workspace for the last 7 days, distributed by the outcome of the job run.
SELECT
  workspace_id,
  COUNT(DISTINCT run_id) as job_count,
  result_state,
  to_date(period_start_time) as date
FROM system.lakeflow.job_run_timeline
WHERE
  period_start_time > CURRENT_TIMESTAMP() - INTERVAL 7 DAYS
  AND result_state IS NOT NULL
GROUP BY ALL

-- This query returns the average time of job runs, measured in seconds. The records are organized by job. A top 90 and a 95 percentile column show the average lengths of the job's longest runs.
with job_run_duration as (
    SELECT
        workspace_id,
        job_id,
        run_id,
        CAST(SUM(period_end_time - period_start_time) AS LONG) as duration
    FROM
        system.lakeflow.job_run_timeline
    WHERE
      period_start_time > CURRENT_TIMESTAMP() - INTERVAL 7 DAYS
    GROUP BY ALL
)
SELECT
    t1.workspace_id,
    t1.job_id,
    COUNT(DISTINCT t1.run_id) as runs,
    MEAN(t1.duration) as mean_seconds,
    AVG(t1.duration) as avg_seconds,
    PERCENTILE(t1.duration, 0.9) as p90_seconds,
    PERCENTILE(t1.duration, 0.95) as p95_seconds
FROM
    job_run_duration t1
GROUP BY ALL
ORDER BY mean_seconds DESC
LIMIT 100

-- This query provides a historical runtime for a specific job based on the `run_name` parameter. For the query to work, you must set the `run_name`.
SELECT
  workspace_id,
  run_id,
  SUM(period_end_time - period_start_time) as run_time
FROM system.lakeflow.job_run_timeline
WHERE
  run_type="SUBMIT_RUN"
  AND run_name={run_name}
  AND period_start_time > CURRENT_TIMESTAMP() - INTERVAL 60 DAYS
GROUP BY ALL

-- This query collects a list of retried job runs with the number of retries for each run.
with repaired_runs as (
    SELECT
    workspace_id, job_id, run_id, COUNT(*) - 1 as retries_count
    FROM system.lakeflow.job_run_timeline
    WHERE result_state IS NOT NULL
    GROUP BY ALL
    HAVING retries_count > 0
    )
SELECT
    *
FROM repaired_runs
ORDER BY retries_count DESC
    LIMIT 10;

Tidslinje för utförande av arbetsuppgift tableschema

Tidslinjen för körning av jobbaktivitet table är oföränderlig och slutförd när den skapas.

Table sökväg: system.lakeflow.job_task_run_timeline

Column namn	Datatyp	beskrivning	Anteckningar
account_id	sträng	ID:t för det konto som jobbet tillhör
workspace_id	sträng	ID:t för arbetsytan som det här jobbet tillhör
job_id	sträng	Jobbets ID	Endast unikt inom en enda arbetsyta
run_id	sträng	ID för aktivitetskörningen
job_run_id	sträng	ID:t för jobbkörningen	Fylls inte i för rader som genereras före slutet av augusti 2024
parent_run_id	sträng	ID för den överordnade körningen	Fylls inte i för rader som genereras före slutet av augusti 2024
period_start_time	timestamp	Starttiden för aktiviteten eller för tidsperioden	Timezone information registreras i slutet av värdet med +00:00 som står för UTC
period_end_time	timestamp	Sluttiden för aktiviteten eller för tidsperioden	Information om Timezone registreras i slutet av värdet med +00:00 som representerar UTC
task_key	sträng	Referensnyckeln för en uppgift i ett jobb	Den här nyckeln är bara unik i ett enda jobb
compute_ids	matris	Matrisen compute_ids innehåller ID:t för jobbkluster, interaktiva kluster och SQL-lager som används av jobbaktiviteten
result_state	sträng	Resultatet av jobbaktivitetskörningen	För möjliga values, se resultat tillstånd values
termination_code	sträng	Avslutningskoden för aktivitetskörningen	För möjliga values, se avslutningskod values. Fylls inte i för rader som genereras före slutet av augusti 2024

Vanliga join mönster

Följande avsnitt innehåller exempelfrågor som markerar vanliga join mönster för jobbsystem tables.

Join tidslinjen för jobb och jobbkörning tables

Enrich-jobbkörning med ett jobbnamn

with jobs as (
    SELECT
        *,
        ROW_NUMBER() OVER (PARTITION BY workspace_id, job_id ORDER BY change_time DESC) as rn
    FROM system.lakeflow.jobs QUALIFY rn=1
)
SELECT
    job_run_timeline.*
    jobs.name
FROM system.lakeflow.job_run_timeline
    LEFT JOIN jobs USING (workspace_id, job_id)

Utöka användning med ett jobbnamn

with jobs as (
  SELECT
    *,
    ROW_NUMBER() OVER (PARTITION BY workspace_id, job_id ORDER BY change_time DESC) as rn
  FROM system.lakeflow.jobs QUALIFY rn=1
)
SELECT
  usage.*,
  coalesce(usage_metadata.job_name, jobs.name) as job_name
FROM system.billing.usage
  LEFT JOIN jobs ON usage.workspace_id=jobs.workspace_id AND usage.usage_metadata.job_id=jobs.job_id
WHERE
  billing_origin_product="JOBS"

Join tidslinjen för körning av jobbet och användningen tables

Utöka varje faktureringslogg med jobbkörningsmetadata

SELECT
    t1.*,
    t2.*
FROM system.billing.usage t1
    LEFT JOIN system.lakeflow.job_run_timeline t2
        ON t1.workspace_id = t2.workspace_id
            AND t1.usage_metadata.job_id = t2.job_id
            AND t1.usage_metadata.job_run_id = t2.run_id
            AND t1.usage_start_time >= date_trunc("Hour", t2.period_start_time)
            AND t1.usage_start_time < date_trunc("Hour", t2.period_end_time) + INTERVAL 1 HOUR
WHERE
    billing_origin_product="JOBS"

Beräkna kostnad per jobbkörning

Den här frågan kopplas till billing.usage-systemet table för att beräkna kostnaden för varje jobbkörning.

with jobs_usage AS (
  SELECT
    *,
    usage_metadata.job_id,
    usage_metadata.job_run_id as run_id,
    identity_metadata.run_as as run_as
  FROM system.billing.usage
  WHERE billing_origin_product="JOBS"
),
jobs_usage_with_usd AS (
  SELECT
    jobs_usage.*,
    usage_quantity * pricing.default as usage_usd
  FROM jobs_usage
    LEFT JOIN system.billing.list_prices pricing ON
      jobs_usage.sku_name = pricing.sku_name
      AND pricing.price_start_time <= jobs_usage.usage_start_time
      AND (pricing.price_end_time >= jobs_usage.usage_start_time OR pricing.price_end_time IS NULL)
      AND pricing.currency_code="USD"
),
jobs_usage_aggregated AS (
  SELECT
    workspace_id,
    job_id,
    run_id,
    FIRST(run_as, TRUE) as run_as,
    sku_name,
    SUM(usage_usd) as usage_usd,
    SUM(usage_quantity) as usage_quantity
  FROM jobs_usage_with_usd
  GROUP BY ALL
)
SELECT
  t1.*,
  MIN(period_start_time) as run_start_time,
  MAX(period_end_time) as run_end_time,
  FIRST(result_state, TRUE) as result_state
FROM jobs_usage_aggregated t1
  LEFT JOIN system.lakeflow.job_run_timeline t2 USING (workspace_id, job_id, run_id)
GROUP BY ALL
ORDER BY usage_usd DESC
LIMIT 100

Get användningsloggar för ett SUBMIT_RUN jobb

SELECT
  *
FROM system.billing.usage
WHERE
  EXISTS (
      SELECT 1
      FROM system.lakeflow.job_run_timeline
      WHERE
        job_run_timeline.job_id = usage_metadata.job_id
        AND run_name={run_name}
        AND workspace_id={workspace_id}
  )

Join tidslinjen och klustren för jobbaktivitetskörningen tables

Enrich-jobbaktivitet körs med klustermetadata

with clusters as (
    SELECT
        *,
        ROW_NUMBER() OVER (PARTITION BY workspace_id, cluster_id ORDER BY change_time DESC) as rn
    FROM system.compute.clusters QUALIFY rn=1
),
exploded_task_runs AS (
  SELECT
    *,
    EXPLODE(compute_ids) as cluster_id
  FROM system.lakeflow.job_task_run_timeline
  WHERE array_size(compute_ids) > 0
)
SELECT
  exploded_task_runs.*,
  clusters.*
FROM exploded_task_runs t1
  LEFT JOIN clusters t2
    USING (workspace_id, cluster_id)

Hitta jobb som körs på allmän beräkningsmiljö

Den här frågan ansluter till compute.clusters system table för att returnera de senaste jobben som körs på all-purpose compute i stället för jobbberäkning.

with clusters AS (
  SELECT
    *,
    ROW_NUMBER() OVER(PARTITION BY workspace_id, cluster_id ORDER BY change_time DESC) as rn
  FROM system.compute.clusters
  WHERE cluster_source="UI" OR cluster_source="API"
  QUALIFY rn=1
),
job_tasks_exploded AS (
  SELECT
    workspace_id,
    job_id,
    EXPLODE(compute_ids) as cluster_id
  FROM system.lakeflow.job_task_run_timeline
  WHERE period_start_time >= CURRENT_DATE() - INTERVAL 30 DAY
),
all_purpose_cluster_jobs AS (
  SELECT
    t1.*,
    t2.cluster_name,
    t2.owned_by,
    t2.dbr_version
  FROM job_tasks_exploded t1
    INNER JOIN clusters t2 USING (workspace_id, cluster_id)
)
SELECT * FROM all_purpose_cluster_jobs LIMIT 10;

övervakningsinstrumentpanel för jobb

Följande instrumentpanel använder system tables för att hjälpa dig get börjat övervaka dina jobb och driftshälsa. Den innehåller vanliga användningsfall som spårning av jobbprestanda, felövervakning och resursanvändning.

Information om hur du laddar ned instrumentpanelen finns i Övervaka jobbkostnader & prestanda med system tables

Felsökning

jobb loggas inte i lakeflow.jobstable

Om ett jobb inte visas i systemet tables:

• Jobbet har inte ändrats under de senaste 365 dagarna
  • Ändra något av jobbets fält som finns i schema för att generera en ny post.
• Jobbet skapades i en annan region
• Senaste jobbskapande (table tidsförskjutning)

Det går inte att hitta ett jobb som visas i job_run_timelinetable

Alla jobbkörningar visas inte överallt. Även om JOB_RUN-poster visas i alla jobbrelaterade tables, registreras WORKFLOW_RUN (notebook-arbetsflödeskörningar) endast i job_run_timeline och SUBMIT_RUN (en gång skickade körningar) registreras endast i båda tidslinjerna tables. Dessa körningar fylls inte i i andra jobbsystem tables som jobs eller job_tasks.

Se Kör typernatable nedan för en detaljerad uppdelning av where varje typ av körning är synlig och tillgänglig.

Jobbkörningen visas inte i billing.usagetable

I system.billing.usagefylls usage_metadata.job_id bara i för jobb som körs på jobbberäkning eller serverlös beräkning.

Dessutom har WORKFLOW_RUN jobb inte egna usage_metadata.job_id eller usage_metadata.job_run_id tilldelning i system.billing.usage. I stället tillskrivs deras beräkningsanvändning den överordnade anteckningsboken som utlöste dem. Det innebär att när en notebook-fil startar en arbetsflödeskörning visas alla beräkningskostnader under den överordnade notebook-filens användning, inte som ett separat arbetsflödesjobb.

Mer information finns i Analysera användningsmetadata.

Beräkna kostnaden för ett jobb som körs på universell datorkraft

Exakt kostnadsberäkning för jobb som körs på specialiserad beräkningsresurs är inte möjlig med 100% noggrannhet. När ett jobb körs på en interaktiv (all-purpose) beräkning körs ofta flera arbetsbelastningar som notebook-filer, SQL-frågor eller andra jobb samtidigt på samma beräkningsresurs. Eftersom klusterresurserna delas finns det ingen direkt 1:1-mappning mellan beräkningskostnader och enskilda jobbkörningar.

För korrekt jobbkostnadsspårning rekommenderar Databricks att du kör jobb på dedikerad jobbberäkning eller serverlös beräkning, whereusage_metadata.job_id och usage_metadata.job_run_id möjliggöra exakt kostnadsattribution.

Om du måste använda all-purpose compute kan du:

• Övervaka övergripande klusteranvändning och kostnader i system.billing.usage baserat på usage_metadata.cluster_id.
• Spåra jobbkörningsmått separat.
• Tänk på att alla kostnadsuppskattningar kommer att vara ungefärliga på grund av delade resurser.

Mer information om kostnadstillskrivning finns i Analysera användningsmetadata.

Referens values

Följande avsnitt innehåller referenser för selectcolumns inom jobbrelaterade tables.

utlösartyp values

Möjliga values för trigger_typecolumn är:

• CONTINUOUS
• CRON
• FILE_ARRIVAL
• ONETIME
• ONETIME_RETRY

Kör typ values

Möjliga values för run_typecolumn är:

Typ	beskrivning	UI-plats	API-slutpunkt	System Tables
JOB_RUN	Standardjobbutförande	Jobb & jobb kör användargränssnittet	/jobs och /jobs/runs ändpunkter	jobb, arbetsuppgifter, körtid för jobb, körtid för arbetsuppgift
SUBMIT_RUN	Engångskörning via POST /jobs/runs/submit	Endast jobbkörningsanvändargränssnittet	/jobs/runs endpoint enbart	jobbkörningslinje, arbetstidslinje för jobbuppgifter
WORKFLOW_RUN	Kör initierat från notebook-arbetsflöde	Inte synlig	Inte tillgänglig	jobbkörningstidslinje

resultattillstånd values

Möjliga values för result_statecolumn är:

Stat	beskrivning
SUCCEEDED	Körningen har slutförts framgångsrikt
FAILED	Körningen slutfördes med ett fel
SKIPPED	Körning utfördes aldrig eftersom ett villkor inte uppfylldes
CANCELLED	Körningen avbröts på användarens begäran
TIMED_OUT	Körningen stoppades efter att tidsgränsen nåtts
ERROR	Körningen slutfördes med ett fel
BLOCKED	Körningen blockerades på grund av ett uppströmsberoende

avslutningskod values

Möjliga values för termination_codecolumn är:

Avslutningskod	beskrivning
SUCCESS	Körningen har slutförts
CANCELLED	Körningen avbröts av Databricks-plattformen under utförandet, till exempel om den maximala körningstiden överskreds.
SKIPPED	Körningen utfördes aldrig, till exempel om den föregående aktivitetskörningen misslyckades, beroendevillkoret inte uppfylldes eller om det inte fanns några aktuella uppgifter att köra
DRIVER_ERROR	Körningen påträffade ett fel vid kommunikation med Spark-drivrutinen
CLUSTER_ERROR	Körningen misslyckades på grund av ett klusterfel
REPOSITORY_CHECKOUT_FAILED	Det gick inte att slutföra utcheckningen på grund av ett fel vid kommunikation med tjänsten från tredje part
INVALID_CLUSTER_REQUEST	Körningen misslyckades eftersom den utfärdade en ogiltig begäran om att starta klustret
WORKSPACE_RUN_LIMIT_EXCEEDED	Arbetsytan har nått kvoten för det maximala antalet samtidiga aktiva körningar. Överväg att schemalägga körningarna över en större tidsram
FEATURE_DISABLED	Körningen misslyckades eftersom den försökte komma åt en funktionalitet som inte är tillgänglig för arbetsytan
CLUSTER_REQUEST_LIMIT_EXCEEDED	Antalet begäranden om att skapa, starta och utvidga kluster har överskridit den tilldelade hastigheten limit. Överväg att sprida körningens genomförande över en större tidsram
STORAGE_ACCESS_ERROR	Körningen misslyckades på grund av ett fel vid åtkomst till kundens bloblagringssystem
RUN_EXECUTION_ERROR	Körningen slutfördes med aktivitetsfel
UNAUTHORIZED_ERROR	Körningen misslyckades på grund av ett behörighetsproblem vid åtkomst till en resurs
LIBRARY_INSTALLATION_ERROR	Körningen misslyckades när det användar begärda biblioteket skulle installeras. Orsakerna kan vara, men är inte begränsade till: Det angivna biblioteket är ogiltigt, det finns inte tillräckliga behörigheter för att installera biblioteket och så vidare
MAX_CONCURRENT_RUNS_EXCEEDED	Den schemalagda körningen överskrider limit av maximala samtidiga körningar set för jobbet
MAX_SPARK_CONTEXTS_EXCEEDED	Körningen är schemalagd i ett kluster som redan har nått det maximala antalet kontexter som den har konfigurerats för att skapa
RESOURCE_NOT_FOUND	En resurs som krävs för körningen finns inte
INVALID_RUN_CONFIGURATION	Körningen misslyckades på grund av en ogiltig konfiguration
CLOUD_FAILURE	Körningen misslyckades på grund av ett problem med molnleverantören
MAX_JOB_QUEUE_SIZE_EXCEEDED	Körningen hoppades över på grund av att köstorleken på jobbnivå nåddes limit