Utilisation
explore: view_name_1 {
join: view_name_2 {
sql_where: ${view_name_1.id} < 100 ;;
}
}
sql_where
|
Hierarchy
sql_where |
Default Value
None
Accepts
A SQL WHERE clause
|
Definition
sql_where lets you apply a query restriction that users cannot change. The restriction will be inserted into the WHERE clause of the underlying SQL that Looker generates if and only if the join is used in the query. In addition to queries run by human users, the restriction will apply to dashboards, scheduled Looks, and embedded information that relies on that Explore.
The condition can be written in pure SQL, using your database's actual table and column names. It can also use Looker field references like ${view_name.field_name}, which is the preferred method, because Looker can be smarter about automatically including necessary joins. A sql_where condition is not displayed to the user, unless they look at the underlying SQL of any queries that they create.
Example
For example, you can specify that if the join to users is used, that only users younger than 50 should be included:
explore: orders_users_under_50 {
view_name: orders
join: users {
sql_on: ${users.id} = ${orders.user_id} ;;
sql_where: ${users.age} < 50 ;;
type: left_outer
}
}
Si l'utilisateur sélectionne Orders.Count et Users.Count, le code SQL que Looker générera à partir de ce code LookML sera le suivant :
SELECT
COUNT(orders.id) AS orders_count,
COUNT(DISTINCT users.id, 1000) AS users_count
FROM thelook2.orders AS orders
LEFT JOIN thelook2.users AS users ON users.id = orders.user_id
WHERE users.age < 50
LIMIT 500
Éléments à prendre en compte
Les parenthèses sont obligatoires si vous utilisez la logique OR.
Si vous utilisez la logique OR avec sql_where, il est très important de placer des parenthèses autour de la condition SQL. Par exemple, au lieu d'écrire :
sql_where: region = 'Northeast' OR company = 'Altostrat' ;;
Vous devez écrire :
sql_where: (region = 'Northeast' OR company = 'Altostrat') ;;
Si vous avez oublié d'ajouter les parenthèses dans cet exemple et qu'un utilisateur a ajouté son propre filtre, la clause WHERE générée peut se présenter comme suit :
WHERE
user_filter = 'something' AND
region = 'Northeast' OR
company = 'Altostrat'
Dans ce cas, il est possible que le filtre appliqué par l'utilisateur ne fonctionne pas. Quoi qu'il arrive, les lignes avec company = 'Altostrat' s'afficheront, car la condition AND est évaluée en premier. Sans parenthèses, seule une partie de la condition sql_where est combinée au filtre de l'utilisateur. Si des parenthèses ont été ajoutées, la clause WHERE se présentera comme suit :
WHERE
user_filter = 'something' AND
(region = 'Northeast' OR company = 'Altostrat')
Le filtre de l'utilisateur sera désormais appliqué à chaque ligne.
L'ordre des jointures est important pour les dépendances sql_where
En général, Looker implémente les jointures dans le bon ordre, quel que soit l'ordre dans lequel elles sont définies dans le LookML. sql_where fait exception à cette règle. Si vous référencez un champ d'une autre jointure dans votre instruction sql_where, la jointure que vous référencez doit être définie avant votre instruction sql_where dans le code LookML.
Par exemple, voici une instruction sql_where qui référence le champ inventory_items.id avant que inventory_items n'ait été joint :
explore: orders {
hidden: yes
join: order_items {
sql_on: ${order_items.order_id} = ${orders.id} ;;
sql_where: ${inventory_items.id} IS NOT NULL ;;
}
join: inventory_items {
sql_on: ${inventory_items.id}=${order_items.inventory_item_id} ;;
}
}
Si vous exécutez une requête dans cette exploration, Looker renvoie une erreur indiquant que le champ inventory_items.id est introuvable.
Toutefois, vous pouvez résoudre ce problème en réorganisant vos jointures de sorte que celle référencée dans l'instruction sql_where soit définie avant l'instruction sql_where, comme suit :
explore: orders {
hidden: yes
join: inventory_items {
sql_on: ${inventory_items.id}=${order_items.inventory_item_id} ;;
}
join: order_items {
sql_on: ${order_items.order_id} = ${orders.id} ;;
sql_where: ${inventory_items.id} IS NOT NULL ;;
}
}
Cela empêchera l'erreur, car la jointure inventory_items est définie avant que le champ inventory_items.id ne soit référencé dans l'instruction sql_where de la jointure order_items.
La restriction de requête sql_where n'est appliquée que si la jointure est utilisée.
La restriction de requête spécifiée dans sql_where sera insérée dans la clause WHERE du code SQL sous-jacent que Looker génère si et seulement si la jointure est utilisée dans la requête. Si vous souhaitez qu'une clause where soit appliquée même si la jointure n'a pas été utilisée, utilisez plutôt sql_always_where.