relazione

Utilizzo

explore: view_name {
  join: view_name_2 {
    relationship: one_to_one
  }
}

Gerarchia File del modello explore join relationship

Valore predefinito many_to_one Accetta Una relazione (many_to_one, many_to_many, one_to_many, one_to_one)

Definizione

relationship ti consente di descrivere la relazione join tra le viste unite. È importante definire correttamente il tipo di relazione affinché Looker possa calcolare misure accurate.

Per comprendere la relazione che viene definita, considera questo esempio:

explore: order {
  join: user {
    sql_on: ${order.user_id} = ${user.id} ;;
    relationship: many_to_one
  }
  join: user_facts {
    sql_on: ${user.id} = ${user_facts.user_id} ;;
    relationship: one_to_one
  }
}

Quando una visualizzazione viene unita direttamente a un'esplorazione, come la visualizzazione user in questo esempio, la relazione è da Esplora a la visualizzazione unita. In questo caso, stiamo dicendo che potrebbero esserci molti ordini per un utente.

Quando una visualizzazione viene unita a un'esplorazione tramite un'altra visualizzazione, ad esempio come user_facts si unisce tramite user a order in questo esempio, la relazione definita è da la visualizzazione intermedia (user) a la visualizzazione finale (user_facts). In questo esempio, stiamo dicendo che esiste un utente per un record di fatti dell'utente.

I valori possibili per relationship sono descritti in queste sezioni della pagina:

• one_to_one
• many_to_one (valore predefinito)
• one_to_many
• many_to_many

one_to_one

Se una riga in Esplora può corrispondere a una sola riga nella vista unita, la relazione è one_to_one. Ad esempio, una visualizzazione unita user Esplora con user_facts sarebbe one_to_one, poiché entrambe le tabelle hanno una riga per utente.

Una relazione one_to_one richiede che non siano presenti valori null nelle chiavi primarie delle tabelle. Se sono presenti valori null in una o entrambe le chiavi primarie delle tabelle, la relazione è many_to_many o many_to_one.

many_to_one (valore predefinito)

Se molte righe nell'esplorazione possono corrispondere a una riga nella visualizzazione unita, la relazione è many_to_one. Ad esempio, un'esplorazione order con una vista unita user sarebbe many_to_one, perché potrebbero esserci più ordini per utente.

one_to_many

Se una riga in Esplora può corrispondere a molte righe nella vista unita, la relazione è one_to_many. Ad esempio, una visualizzazione unita di order Esplora con item sarebbe one_to_many, perché un ordine può contenere più articoli.

many_to_many

Se molte righe dell'esplorazione possono corrispondere a molte righe della vista unita, la relazione è many_to_many. Ad esempio, una visualizzazione unita Esplora con student many_to_many se uno studente ha più corsi e un corso ha più studenti.class In pratica, le relazioni many-to-many vengono spesso evitate nella progettazione di database SQL, quindi la maggior parte dei modelli non ha bisogno di many_to_many.

Esempi

Dichiara la relazione da user a dna come one_to_one:

explore: user {
  join: dna {
    sql_on: ${user.dna_id} = ${dna.id} ;;
    relationship: one_to_one
  }
}

Dichiara la relazione da order a user come many_to_one:

explore: order {
  join: user {
    sql_on: ${order.user_id} = ${user.id} ;;
    relationship: many_to_one
  }
}

Dichiara la relazione da order a item come one_to_many:

explore: order {
  join: item {
    sql_on: ${order.order_id} = ${item.order_id} ;;
    relationship: one_to_many
  }
}

Dichiara la relazione da student a class come many_to_many:

explore: student {
  join: class {
    sql_on: ${student.student_id} = ${class.student_id} ;;
    relationship: many_to_many
  }
}

Dichiara la relazione da user a user_type come many_to_one:

explore: order {
  join: user {
    sql_on: ${order.user_id} = ${user.id} ;;
    relationship: many_to_one
  }
  join: user_type {
    sql_on: ${user.type_id} = ${user_type.id} ;;
    relationship: many_to_one
  }
}