LookML significa lenguaje de modelado de Looker, el lenguaje que se usa en Looker para crear modelos de datos semánticos. Puede usar LookML para describir dimensiones, agregados, cálculos y relaciones de datos en su base de datos SQL. Looker usa un modelo escrito en LookML para crear consultas de SQL en una base de datos en particular.
LookML es un lenguaje de dependencia como make, a diferencia de un lenguaje imperativo como C o Ruby. LookML proporciona sintaxis y tipos de datos predefinidos para el modelado de datos. La sintaxis de LookML tiene una estructura clara y fácil de aprender. No necesitas tener experiencia previa con lenguajes de programación para comprender LookML: todo lo que necesitas saber está documentado aquí. LookML es independiente de dialectos de SQL particulares y encapsula expresiones de SQL para admitir cualquier implementación de SQL.
Para los analistas de datos, LookML promueve 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 varias veces para generar consultas ad hoc de SQL. Luego, los usuarios empresariales pueden usar los resultados para crear consultas complejas en Looker y enfocarse solo en el contenido que necesitan, no en las complejidades de la estructura de SQL.
Proyectos de LookML
LookML se define en proyectos. Un proyecto de LookML es una colección de archivos que incluyen, al menos, archivos de vista y modelo y, opcionalmente, otros tipos de archivos, que suelen controlarse mediante una versión en un repositorio de Git. Los archivos del modelo contienen información sobre qué tablas usará el proyecto y cómo se deberían unir las tablas. Los archivos de vista describen cómo se calcula la información sobre cada tabla (o en varias tablas si las uniones lo permiten).
LookML separa la estructura del contenido, por lo que la estructura de la consulta (cómo se unen las tablas) es independiente del contenido de la consulta (las columnas a las que se accederá, los campos derivados, las funciones agregadas para procesar y las expresiones de filtrado que se aplicarán).
En el siguiente diagrama, se muestran los elementos fundamentales de LookML en un proyecto y sus relaciones. Para obtener más información, consulta los términos y conceptos de LookML.
Qué ven los usuarios
La configuración del proyecto y el contenido específico de sus archivos determinan qué ven los usuarios y cómo pueden interactuar con Looker.
- El menú Explorar está organizado por nombres de modelos. Debajo de cada nombre de modelo, habrá una lista de Exploraciones disponibles definidas en ese modelo.
- Los usuarios pueden buscar en el menú si conocen el nombre de Explorar que deseen.
Los desarrolladores pueden incluir descripciones de los elementos Explora que los usuarios pueden ver cuando colocan el cursor sobre ellos. En este ejemplo, se muestra una exploración llamada Order items.
El panel del selector de campos se organiza según nombres de vista. Debajo de cada nombre de vista, habrá una lista de campos disponibles de las tablas incluidas en esa vista. La mayoría de las vistas muestran dimensiones y medidas. En este ejemplo, se selecciona una dimensión Mes en un grupo de dimensiones Fecha de devolución, que se definió en el archivo de vista.
Los usuarios pueden seleccionar varias medidas en las que basar la consulta.
Los usuarios pueden aplicar opciones como filtros y elementos dinámicos en el panel del selector de campos.
Los usuarios pueden definir mejor los términos de la consulta.
Los usuarios pueden elegir un tipo de visualización para aplicar a los resultados de las consultas.
Cuando se ejecuta esta exploración, se genera una consulta en SQL que muestra una tabla de datos y una visualización del precio de venta total y el margen bruto total de los pedidos devueltos del año pasado.
Muestra de código
En el siguiente ejemplo de código, se muestra un proyecto mínimo de LookML 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 eres nuevo en el desarrollo de LookML, considera usar los recursos que se describen en las siguientes secciones para acelerar tu aprendizaje:
- Obtén acceso al entorno de aprendizaje de Looker
- Aprende a usar Looker para consultar y explorar datos
- Revise los conceptos básicos de SQL antes de profundizar en LookML
- Obtén información básica sobre LookML
- Considera la capacitación de Looker
Obtén acceso al entorno de aprendizaje de Looker
Consulta los cursos en Google Cloud Skills Boost.
Aprende a usar Looker para consultar y explorar datos
Saber cómo explorar datos en Looker lo ayudará en gran medida cuando modele sus datos en LookML. Si no estás familiarizado con el uso de Looker para consultar, filtrar y desglosar datos, te sugerimos los siguientes recursos:
- Comienza con los instructivos para recuperar y recuperar datos. Los vínculos que aparecen al final de cada página te guiarán por una secuencia de las funciones más importantes de Looker.
- En la Quest Boost Data with Looker Skills, conocerás los conceptos básicos de la exploración.
Revise los conceptos básicos de SQL antes de profundizar en LookML
Escribir LookML requiere una comprensión de las consultas de SQL. No es necesario ser gurú de SQL; incluso los principiantes pueden crear modelos potentes de Looker. Pero, en general, mientras más se profundiza en LookML, más se beneficia un conocimiento más profundo de SQL.
Si necesitas hacer un repaso de SQL, estos son algunos de nuestros recursos favoritos:
- Instructivos interactivos de SQL de lecciones de SQL de Khan Academy
- Instructivos interactivos de SQL de SQLZoo
- Sams Teach Yourself SQL in 10 minutes, libro de Ben Forta
Aprende los aspectos básicos de LookML
Estos recursos iniciarán sus conocimientos de LookML. Usa tu cuenta de aprendizaje para experimentar con diferentes patrones de diseño.
- Comienza con Términos y conceptos de LookML.
- Continúa con Cómo Looker genera SQL y Conceptos avanzados de LookML.
- Una vez que conozca bien LookML y SQL, obtenga información sobre nuestras funciones más avanzadas, como las tablas derivadas y los filtros basados en plantillas.
Una vez que hayas aprendido los aspectos básicos de LookML, consulta las siguientes páginas para obtener descripciones generales de los diferentes tipos de parámetros de LookML:
- Parámetros del modelo
- Explora los parámetros
- Une parámetros
- Parámetros de vista
- Parámetros de campo
- Parámetros del panel