Introducción a LookML

LookML, abreviatura de Looker Modeling Language (lenguaje de modelado de Looker), es el lenguaje que se usa en Looker para crear modelos de datos semánticos. Puedes usar LookML para describir dimensiones, agregaciones, cálculos y relaciones de datos en tu base de datos SQL. Looker usa un modelo escrito en LookML para crear consultas de SQL en una base de datos concreta.

LookML es un lenguaje de dependencia como make, a diferencia de los lenguajes imperativos como C o Ruby. LookML proporciona tipos de datos y sintaxis predefinidos para el modelado de datos. No es necesario tener experiencia previa con lenguajes de programación para entender LookML. LookML es independiente de los dialectos de SQL y encapsula expresiones SQL para admitir cualquier implementación de SQL.

Para los analistas de datos, LookML fomenta el estilo DRY ("no te repitas"), lo que significa que escribes expresiones SQL una vez, en un solo lugar, y Looker usa el código repetidamente para generar consultas SQL ad hoc. De esta forma, los usuarios empresariales pueden usar los resultados para crear consultas complejas en Looker, centrándose solo en el contenido que necesitan, no en las complejidades de la estructura SQL.

Proyectos de LookML

LookML se define en proyectos. Un proyecto de LookML es una colección de archivos que incluye al menos archivos de modelo y de vista, y, opcionalmente, otros tipos de archivos, que normalmente se controlan mediante versiones a través de un repositorio de Git. Los archivos de modelo contienen información sobre las tablas que usará el proyecto y cómo se deben unir. Los archivos de vista describen cómo se calcula la información de cada tabla (o de varias tablas si las uniones lo permiten).

LookML separa la estructura del contenido, por lo que la estructura de la consulta (cómo se combinan las tablas) es independiente del contenido de la consulta (las columnas a las que se accede, los campos derivados, las funciones de agregación que se van a calcular y las expresiones de filtro que se van a aplicar).

Las consultas de Looker se basan en archivos de proyectos de LookML. Los analistas de datos usan LookML para crear y mantener modelos de datos que definen la estructura de los datos y las reglas de negocio de los datos que se están analizando. El generador de SQL de Looker traduce LookML a SQL, lo que permite a los usuarios empresariales hacer consultas sin escribir código LookML ni SQL.

Los usuarios empresariales usan el compilador de consultas de Looker o la interfaz Explorar para crear consultas basadas en el modelo de datos que definen los analistas de Looker. Los usuarios pueden seleccionar dimensiones, métricas y filtros para crear consultas personalizadas basadas en sus propias preguntas y generar sus propias estadísticas.

Cuando un usuario crea una consulta, se envía al generador de SQL de Looker, que la traduce a SQL. La consulta SQL se ejecuta en la base de datos y, a continuación, Looker devuelve los resultados formateados al usuario en la interfaz Explorar. Después, el usuario puede visualizar los resultados y generar estadísticas.

Para obtener más información sobre los elementos fundamentales de LookML en un proyecto y cómo se relacionan entre sí, consulta Términos y conceptos de LookML.

Qué ven los usuarios

La configuración del proyecto y el contenido específico de sus archivos determinan lo que ven los usuarios y cómo pueden interactuar con Looker.

  1. El panel Explorar del panel de navegación de la izquierda se organiza por nombres de modelo. Debajo del nombre de cada modelo, verás una lista de las Exploraciones disponibles que se definen en ese modelo.
  2. Los usuarios pueden buscar un Explorar específico.

  3. Los desarrolladores pueden definir descripciones para las Exploraciones, que los usuarios pueden ver colocando el cursor sobre el nombre de la Exploración en el menú Explorar.

  4. El panel del selector de campos se organiza por nombres de vista. Debajo del nombre de cada vista, verás una lista de los campos disponibles de las tablas incluidas en esa vista. En la mayoría de las vistas se muestran tanto dimensiones como medidas. En este ejemplo, se selecciona la dimensión Mes de un grupo de dimensiones Fecha de devolución, que se definió en el archivo de vista.

  5. Los usuarios pueden seleccionar varias medidas en las que basar la consulta.

  6. Los usuarios pueden aplicar opciones como filtros y tablas dinámicas en el panel de selección de campos.

  7. Los usuarios pueden acotar los términos de la consulta.

  8. Los usuarios pueden elegir un tipo de visualización para aplicarlo a los resultados de la consulta.

  9. Al ejecutar este Exploración, se genera una consulta de SQL que devuelve una tabla de datos y una visualización del precio de venta total y del margen bruto total de los pedidos devueltos del año pasado.

Código de ejemplo

En el siguiente ejemplo de código se muestra un proyecto de LookML mínimo para una tienda de comercio electrónico, que tiene un archivo de modelo (ecommercestore.model.lkml) y dos archivos de vista (orders.view.lkml y customers.view.lkml):

######################################
# FILE: ecommercestore.model.lkml    #
# Define the explores and join logic #
######################################
connection: order_database
include: "*.view.lkml"
explore: orders {
  join: customers {
    sql_on: ${orders.customer_id} = ${customers.id} ;;
  }
}

##########################################################
# FILE: orders.view.lkml                                 #
# Define the dimensions and measures for the ORDERS view #
##########################################################
view: orders {
  dimension: id {
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }
  dimension: customer_id {      # field: orders.customer_id
    sql: ${TABLE}.customer_id ;;
  }
  dimension: amount {           # field: orders.amount
    type: number
    value_format: "0.00"
    sql: ${TABLE}.amount ;;
  }
  dimension_group: created {                # generates fields:
    type: time                              # orders.created_time, orders.created_date
    timeframes: [time, date, week, month]   # orders.created_week, orders.created_month
    sql: ${TABLE}.created_at ;;
  }
  measure: count {             # field: orders.count
    type: count                # creates a sql COUNT(*)
    drill_fields: [drill_set*] # list of fields to show when someone clicks 'ORDERS Count'
  }
  measure: total_amount {
    type: sum
    sql: ${amount} ;;
  }
  set: drill_set {
    fields: [id, created_time, customers.name, amount]
  }
}

#############################################################
# FILE: customers.view.lkml                                 #
# Define the dimensions and measures for the CUSTOMERS view #
#############################################################
view: customers {
  dimension: id {
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }
  dimension: city {                    # field: customers.city
    sql: ${TABLE}.city ;;
  }
  dimension: state {                   # field: customers.state
    sql: ${TABLE}.state ;;
  }
  dimension: name {
    sql: CONCAT(${TABLE}.firstname, " ", ${TABLE}.lastname) ;;
  }
  measure: count {             # field: customers.count
    type: count                # creates a sql COUNT(*)
    drill_fields: [drill_set*] # fields to show when someone clicks 'CUSTOMERS Count'
  }
  set: drill_set {                     # set: customers.drill_set
    fields: [id, state, orders.count]  # list of fields to show when someone clicks 'CUSTOMERS Count'
  }
}

Recursos adicionales

Si no tienes experiencia en el desarrollo de LookML, te recomendamos que utilices los recursos que se describen en las siguientes secciones para acelerar tu aprendizaje:

Acceder al entorno de aprendizaje de Looker

Consulta los cursos de Google Cloud Skills Boost.

Aprender a usar Looker para consultar y explorar datos

Saber cómo explorar datos en Looker te será de gran ayuda cuando modelices tus datos en LookML. Si no sabes cómo usar Looker para consultar, filtrar y desglosar datos, te recomendamos los siguientes recursos:

Repasar los conceptos básicos de SQL antes de profundizar en LookML

Para escribir LookML, es necesario conocer las consultas de SQL. No es necesario ser un experto en SQL, ya que incluso los principiantes pueden crear modelos de Looker potentes. Sin embargo, en general, cuanto más profundices en LookML, más te beneficiarás de un conocimiento más profundo de SQL.

Si necesitas repasar SQL, aquí tienes algunos de nuestros recursos favoritos:

Aprender los conceptos básicos de LookML

Estos recursos te ayudarán a ponerte al día con LookML. Usa tu cuenta de aprendizaje para experimentar con diferentes patrones de diseño.

Una vez que hayas aprendido los conceptos básicos de LookML, consulta las siguientes páginas para ver descripciones generales de los distintos tipos de parámetros de LookML: