LookML, abreviatura de Looker Modeling Language, 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 en SQL sobre una base de datos en particular.
LookML es un lenguaje de dependencias como make, a diferencia de un lenguaje imperativo como C o Ruby. LookML proporciona tipos de datos predefinidos y sintaxis para el modelado de datos. No necesitas experiencia previa con lenguajes de programación para entender LookML. 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 fomenta el estilo DRY (“no te repitas”), lo que significa que escribes expresiones de SQL una vez en un solo lugar, y Looker usa el código repetidamente para generar consultas en SQL ad hoc. Luego, los usuarios empresariales pueden usar los resultados para compilar consultas complejas en Looker y enfocarse 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 vista y, opcionalmente, otros tipos de archivos, que suelen controlarse por versión en conjunto mediante un repositorio de Git. Los archivos del modelo contienen información sobre qué tablas usará el proyecto y cómo se deben unir. Los archivos de vista describen cómo se calcula la información sobre cada tabla (o en múltiples 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 accede, los campos derivados, las funciones de agregación para calcular y las expresiones de filtrado que se deben aplicar).
Las consultas de Looker se basan en archivos de proyecto de LookML. Los analistas de datos usan LookML para crear y mantener modelos de datos que definen la estructura de datos y las reglas empresariales de los datos que se analizan. El generador de SQL de Looker traduce LookML a SQL, lo que permite que los usuarios empresariales realicen consultas sin escribir ningún tipo de LookML ni SQL.
Los usuarios empresariales usan el compilador de consultas de Looker o la interfaz de Explorar para crear consultas que se basan en el modelo de datos que definen los analistas de Looker. Los usuarios pueden seleccionar dimensiones, medidas y filtros para crear consultas personalizadas que se basen en sus propias preguntas y generar sus propias estadísticas.
Cuando un usuario crea una consulta, se envía al generador SQL de Looker, que la traduce a SQL. La consulta en SQL se ejecuta en la base de datos y, luego, Looker muestra los resultados con formato al usuario en la interfaz de Explorar. Luego, el usuario puede visualizar los resultados y generar estadísticas.
Para obtener más detalles sobre los elementos fundamentales de LookML en un proyecto y cómo se relacionan entre sí, consulta los Términos y conceptos de LookML.
Qué ven los usuarios
La forma en que se configura el proyecto y el contenido específico de sus archivos determinan lo que los usuarios ven y cómo pueden interactuar con Looker.
- El panel Explorar del panel de navegación izquierdo se organiza por nombres de model. Debajo de cada nombre de modelo, hay una lista de Exploraciones disponibles que se definen en ese modelo.
- Los usuarios pueden buscar una exploración específica.
Los desarrolladores pueden definir descripciones de Explorar, que los usuarios pueden ver si colocan el cursor sobre el nombre de la función Explorar en el menú Explorar.
El panel del selector de campos se organiza por nombres de vista. Debajo de cada nombre de vista, verás una lista de los campos disponibles de las tablas que se incluyen en ella. La mayoría de las vistas muestran tanto dimensiones como medidas. En este ejemplo, se selecciona una dimensión Mes dentro de un grupo de dimensiones Fecha de devolución, que se definió en el archivo de vista.
Los usuarios pueden seleccionar varias mediciones en las que basar la consulta.
Los usuarios pueden aplicar opciones como filtros y tablas dinámicas 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 la consulta.
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 oferta 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
- Revisa los conceptos básicos de SQL antes de sumergirte en LookML
- Conoce los aspectos básicos de LookML
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 te ayudará mucho cuando modeles tus datos en LookML. Si no sabes cómo usar Looker para realizar consultas, filtrar y desglosar datos, te sugerimos los siguientes recursos:
- Comienza con los instructivos para recuperar y representar datos en gráficos. Los vínculos que aparecen en la parte inferior de cada página te guiarán a través de una secuencia de las funciones más importantes de Looker.
- La Quest Analyze and Visualizing Data in Looker skills Boost te guiará a través de los conceptos básicos de la exploración.
Revisa los conceptos básicos de SQL antes de sumergirte en LookML
La escritura de LookML requiere comprender las consultas en SQL. No es necesario que seas un experto en SQL; incluso los principiantes pueden crear modelos potentes de Looker. 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 hacer un repaso de SQL, estos son algunos de nuestros recursos favoritos:
- Instructivos interactivos sobre SQL lecciones de SQL de Khan Academy
- Instructivos interactivos de SQL de SQLZoo
- Libro Sams Teach Yourself SQL in 10 minutes de Ben Forta
Conoce los aspectos básicos de LookML
Estos recursos impulsarán tu conocimiento de LookML. Usa tu cuenta de aprendizaje para experimentar con diferentes patrones de diseño.
- Comienza con los términos y conceptos de LookML.
- Continúa con Cómo Looker genera SQL y Conceptos avanzados de LookML.
- Cuando comprendas LookML y SQL, consulta nuestras funciones más avanzadas, como las tablas derivadas y los filtros con plantillas.
Una vez que hayas aprendido los conceptos 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
- Explorar parámetros
- Parámetros de unión
- Ver parámetros
- Parámetros de campo
- Parámetros del panel