Campos (para las Exploraciones)

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

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

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: explore_name {
  fields: [
    field-or-set-specification,
    field-or-set-specification,
    ...
  ]
}

Jerarquía Archivo del modelo explore fields

Valor predeterminado ALL_FIELDS* Acepta Corchetes que contienen una lista de campos o conjuntos separados por comas Reglas especiales Todos los campos y conjuntos deben tener un alcance completo (usar la sintaxis view_name.field_name). Para excluir campos y conjuntos, antepón un guion (-). Los nombres de los conjuntos siempre terminan con un asterisco (*). Puedes usar el nombre del conjunto integrado ALL_FIELDS*, que incluye todos los campos de la exploración. Puedes usar el nombre del conjunto integrado view_name*, que incluye todos los campos de la vista a la que se hace referencia.

Definición

fields te permite especificar qué campos de una Exploración se exponen en la IU de Explorar. Estos campos pueden estar en la vista base de la Exploración o estar disponibles en las uniones de la Exploración. Si no usas fields, Looker expondrá todos los campos de forma predeterminada.

Se puede usar una lista de campos de la siguiente manera: [view_name.field_a, view_name.field_b].

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

En ambos casos, ten en cuenta que el campo o el conjunto deben tener un alcance completo. En otras palabras, debes incluir el nombre de la vista y el nombre del campo.

Looker crea automáticamente un conjunto llamado ALL_FIELDS*, que contiene todos los campos de la vista base y las uniones de Explorar. Esto es particularmente útil para excluir algunos campos no deseados, como en el siguiente ejemplo:

explore: view_name {
  fields: [ALL_FIELDS*, -joined_view_name.unwanted_field]
}

Looker también crea automáticamente conjuntos que contienen todos los campos de una vista determinada, a los que se puede hacer referencia con el formato view_name*. Por ejemplo, el siguiente Explore incluye solo los campos de la vista customers:

explore: all_people {
  fields: [customers*]
}

Ejemplos

Solo muestra el campo llamado name de la vista customer en la exploración customer:

explore: customer {
  fields: [customer.name]
}

Solo muestra los campos llamados name, address y age de la vista customer en el Explorador de customer:

explore: customer {
  fields: [customer.name, customer.address, customer.age]
}

Solo muestra el conjunto de campos del conjunto export_fields, desde la vista customer, en el Explorar customer:

explore: customer {
  fields: [customer.export_fields*]
}

Excluye el campo llamado status en la vista customer de la exploración order:

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

Información importante

Puedes excluir elementos individuales o conjuntos de elementos con fields y explore.

Puedes usar 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} ;;
  }
}

Pudimos hacer referencia a los campos de la vista unida customer en el parámetro fields del nivel de Exploración con la sintaxis view_name.field_name.

Con la sintaxis -, también puedes excluir conjuntos de campos definidos:

explore: orders {
  fields: [ALL_FIELDS*, -users.statezip*]
  join: users {
    sql_on: ${orders.user_id} = ${users.id} ;;
    relationship: many_to_one
  }
}

view: users {
  set: statezip {
    fields:[state, zip]
  }
}

El parámetro fields que forma parte de un join no puede usar el conjunto ALL_FIELDS.

En esta página, se hace referencia al parámetro fields, que es secundario de explore. Cuando usas el parámetro fields de esta manera, puedes acceder al conjunto ALL_FIELDS* y, luego, excluir los campos no deseados, como se mostró anteriormente.

También hay un parámetro fields que es hijo de join. Cuando se usa de esa manera, no puedes usar el conjunto ALL_FIELDS*.

El conjunto ALL_FIELDS está limitado por el parámetro fields que forma parte de un join.

En esta página, se describe fields cuando se anida en un parámetro explore. También hay un parámetro fields similar que está anidado en join. Es importante comprender las implicaciones de aplicar fields a ambos niveles al mismo tiempo.

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, ocurre lo siguiente:

• Todos los campos de orders estarán disponibles y se incluirán en ALL_FIELDS*.
• name de users estará disponible y se incluirá en ALL_FIELDS*.
• Otros campos en users no estarían disponibles ni se incluirían en el conjunto ALL_FIELDS*.

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].