Campos (para uniones)

En esta página, se hace referencia al parámetro fields que forma parte de una unión.

fields también se puede usar como parte de una exploración, como se describe en la página de documentación del parámetro fields (para exploraciones).

fields también se puede usar como parte de un conjunto, como se describe en la página de documentación del parámetro set.

Uso

explore: view_name_1 {
  join: view_name_2 {
    fields: [
      field-or-set-specification,
      field-or-set-specification,
      ...
    ]
  }
}
Jerarquía
explore
join
fields
Valor predeterminado
Todos los campos de la vista combinada

Acepta
Corchetes que contienen una lista de campos o conjuntos separados por comas

Reglas especiales
  • Los nombres de los conjuntos siempre terminan con un asterisco (*).
  • A nivel de la unión, los campos y los conjuntos solo se pueden incluir, no excluir. Sin embargo, puedes excluir todos los campos con el parámetro fields y una lista vacía, de la siguiente manera: fields: []

Definición

fields a nivel de la unión te permite especificar qué campos de una vista unida se incorporan a una exploración. Si no usas fields, Looker agregará de forma predeterminada todos los campos de la vista.

Se puede usar una lista de campos, como [field_a, field_b].

También puedes hacer referencia a un conjunto de campos (que se crean con el parámetro set), como [set_a*]. El asterisco le indica a Looker que haces referencia a un nombre de conjunto en lugar de a un nombre de campo.

Ejemplos

Solo agrega el campo llamado name de la vista customer a la exploración order:

explore: order {
  join: customer {
    sql_on: ${order.customer_id} = ${customer.id} ;;
    fields: [name]
  }
}

Agrega los campos llamados name, address y age de la vista customer a la exploración order:

explore: order {
  join: customer {
    sql_on: ${order.customer_id} = ${customer.id} ;;
    fields: [name, address, age]
  }
}

Agrega el conjunto de campos llamado order_fields de la vista customer a la exploración order:

explore: order {
  join: customer {
    sql_on: ${order.customer_id} = ${customer.id} ;;
    fields: [order_fields* ]
  }
}

Desafíos habituales

fields solo puede hacer referencia a campos de su propio join

fields será un elemento secundario de un join, que hace referencia a una vista. Todas las dimensiones o medidas a las que se hace referencia en fields deben formar parte de esa vista. Por ejemplo, supongamos que tenemos lo siguiente:

explore: order {
  join: customer {
    sql_on: ${order.customer_id} = ${customer.id} ;;
    fields: [name]
  }
}

Para que funcione correctamente, debe existir una dimensión o una medición llamada name en la vista customer.

Información importante

Usa fields: [] con una lista vacía para excluir todos los campos

Puedes excluir todos los campos de una vista combinada usando el parámetro fields con una lista vacía en tu unión, de la siguiente manera:

explore: order {
  join: customer {
    fields: []
    sql_on: ${order.customer_id} = ${customer.id} ;;
  }
}

En este ejemplo, no se mostrará ninguno de los campos de la vista customer en la exploración order.

La única forma de quitar campos en el nivel join es excluirlos todos a la vez con fields: []. No puedes usar el conjunto ALL_FIELDS* para excluir todos los campos en el nivel join.

Sin embargo, a nivel de explore, puedes usar el conjunto ALL_FIELDS* para excluir elementos individuales, como se describe en la sección Puedes excluir elementos individuales con fields y explore de esta página.

Puedes excluir elementos individuales con fields y explore.

Cuando fields se anida en un parámetro join, puedes excluir todos los campos a la vez con fields: [] o incluir campos específicos. Sin embargo, no puedes excluir campos específicos de a uno por vez. Por ejemplo, si tuvieras 100 campos y solo quisieras excluir uno de ellos, deberías enumerar los 99 campos que sí deseas.

Sin embargo, puedes anidar fields en el parámetro explore para aprovechar el conjunto ALL_FIELDS* y, luego, excluir campos. Por ejemplo:

explore: order {
  fields: [
    ALL_FIELDS*,
    -customer.unwanted_field_a,
    -customer.unwanted_field_b
  ]
  join: customer {
    sql_on: ${order.customer_id} = ${customer.id} ;;
  }
}

Observa cómo pudimos hacer referencia a los campos de la vista combinada customer en el parámetro fields del nivel de Explorar usando la sintaxis view_name.field_name.

Los diferentes tipos de parámetros de fields se aplican en diferentes momentos.

En esta página, se describe fields cuando se anida en un parámetro join. También hay un parámetro fields similar que está anidado en explore. Cuando se usan ambos al mismo tiempo, se aplican en un orden específico, lo que afecta el comportamiento resultante:

Primero, se aplican todos los parámetros fields en join. Esto crea el conjunto de campos entre los que puede elegir la exploración. Considera el siguiente ejemplo:

explore: orders {
  join: users {
    fields: [name]
    sql_on: ${orders.user_id} = ${users.id} ;;
  }
}

En este caso, los campos que estarán disponibles son todos los de orders y name de users. Este es el grupo de campos que se incluiría en el conjunto ALL_FIELDS* (se describe en la sección sobre cómo excluir elementos individuales).

Ahora, si agregamos un parámetro fields en explore, agregamos una restricción sobre ese conjunto. Supongamos que hicimos lo siguiente:

explore: orders {
  fields: [orders.price, users.address]
  join: users {
    fields: [name]
    sql_on: ${orders.user_id} = ${users.id} ;;
  }
}

En este caso, ocurre lo siguiente:

  • price de orders aparecerá como se espera, ya que está en el conjunto ALL_FIELDS* que creamos.
  • address de users no aparecerá porque no se incluyó cuando se unió users (solo se incluyó name).
  • name de users tampoco aparecerá, ya que no lo agregamos a Explorar en la fila fields: [orders.price, users.address].