sql_trigger_value

Utilisation

view: my_view {
  derived_table: {
    sql_trigger_value: SELECT CURDATE() ;;
    ...
  }
}
Hiérarchie
view
derived_table
sql_trigger_value
Valeur par défaut
Aucun

Acceptation
Instruction SQL qui génère une ligne et une colonne

Définition

Envisagez plutôt d'utiliser un datagroup et datagroup_trigger, comme décrit sur la page de documentation Mettre en cache les requêtes.

sql_trigger_value vous permet de déclencher la régénération d'une table dérivée persistante en fonction d'une instruction SQL que vous fournissez. Si le résultat de l'instruction SQL est différent de la valeur précédente, la table PDT est régénérée.

Le paramètre sql_trigger_value ne prend en compte que la première ligne et la première colonne du code SQL que vous écrivez. Par conséquent, nous vous recommandons vivement d'écrire votre requête de manière à ne renvoyer qu'une seule valeur (une ligne et une colonne). Cela évite toute confusion pour les futurs développeurs et empêche les dialectes SQL non diffusés en flux continu de charger de grands ensembles de résultats en mémoire.

Par défaut, Looker exécute la requête SQL que vous écrivez toutes les cinq minutes, tant qu'une autre table dérivée persistante n'est pas en cours de création. Si les résultats de la requête SQL changent, Looker régénère la table dérivée. Vous pouvez modifier cette programmation selon vos besoins à l'aide du paramètre PDT And Datagroup Maintenance Schedule (Programmation de la maintenance des PDT et des groupes de données) dans les paramètres d'administration de Looker.

Par exemple, supposons que vous exécutiez MySQL et que vous utilisiez :

    sql_trigger_value: SELECT CURDATE() ;;

Les résultats ressembleraient à ceci :

Temps d'exécution de sql_trigger_value Résultat de sql_trigger_value
01-01-2015 00:00 01-01-2015
01-01-2015 00:05 01-01-2015
01-01-2015 00:10 01-01-2015
… …
01-01-2015 23:55 01-01-2015
02-01-2015 00:00 02-01-2015
02-01-2015 00:05 02-01-2015

Vous pouvez constater que la valeur de cette requête SQL change une fois par jour à minuit. La table dérivée est donc régénérée à ces moments-là.

Looker n'effectue pas de conversion de fuseau horaire pour sql_trigger_value. Lorsque vous utilisez sql_trigger_value pour déclencher une régénération de PDT à minuit ou à une heure spécifique de la journée, le déclencheur se produit dans le fuseau horaire pour lequel votre base de données est configurée.

Si votre administrateur vous a accordé l'autorisation develop, vous pouvez forcer la régénération d'une table dérivée avant que sa requête sql_trigger_value n'ait changé. Sélectionnez l'option Rebuild Derived Tables &Run (Régénérer les tables dérivées et exécuter) dans le menu en forme d'engrenage Explore actions (Actions sur les explorations) après avoir exécuté une requête.

Pour en savoir plus sur l'option Rebuild Derived Tables & Run (Régénérer les tables dérivées et exécuter), consultez la page de documentation Tables dérivées dans Looker.

Exemples

Créez une PDT sur MySQL qui se régénère une fois par jour à minuit :

view: clean_events {
  derived_table: {
    sql:
      SELECT *
      FROM events
      WHERE type NOT IN ('test', 'staff') ;;
    sql_trigger_value: SELECT CURDATE() ;;
  }
}

Les sections suivantes montrent le code SQL à utiliser pour différentes stratégies de régénération de PDT sur différents dialectes :

Google BigQuery

Programmation de régénération souhaitée SQL à utiliser
Une fois par jour à minuit (heure du Pacifique) 
SELECT FORMAT_TIMESTAMP('%F', CURRENT_TIMESTAMP(), 'America/Los_Angeles')
Une fois par jour à une heure spécifique 
SELECT FLOOR(((TIMESTAMP_DIFF(CURRENT_TIMESTAMP(),'1970-01-01 00:00:00',SECOND)) - 60*60*3)/(60*60*24))

Remplacez le "3" par l'heure à laquelle vous souhaitez que la régénération ait lieu.
Deux fois par jour à des heures spécifiques 
SELECT CASE
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 4 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 18
    THEN 'between 4am and 6pm'
  ELSE 'between 6pm and 4am'
END

Remplacez 4 et 18 par les heures auxquelles vous souhaitez que la régénération ait lieu.
Trois fois par jour à des heures spécifiques 
SELECT CASE
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 4 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 9
    THEN 'between 4am and 9am'
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 9 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 18
    THEN 'between 9am and 6pm'
  ELSE 'between 6pm and 4am'
END

Remplacez 4, 9 et 18 par les heures auxquelles vous souhaitez que la régénération ait lieu.
Toutes les heures 
SELECT EXTRACT(HOUR FROM CURRENT_TIMESTAMP())
Toutes les 2 heures 
SELECT FLOOR((TIMESTAMP_DIFF(CURRENT_TIMESTAMP(),'1970-01-01 00:00:00',SECOND)) / (2*60*60))

Vous pouvez remplacer le "2" par le nombre d'heures que vous souhaitez entre chaque régénération.
Ne jamais mettre à jour les données 
SELECT 1

MySQL

Programmation de régénération souhaitée SQL à utiliser
Une fois par jour à minuit 
SELECT CURDATE()
Une fois par jour à une heure spécifique (temps universel coordonné, UTC) 
SELECT FLOOR((UNIX_TIMESTAMP(NOW()) - 60*60*3)/(60*60*24))

Remplacez le "3" par l'heure à laquelle vous souhaitez que la régénération ait lieu.
Deux fois par jour à des heures spécifiques 
SELECT CASE
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 4 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 18
    THEN 'between 4am and 6pm'
  ELSE 'between 6pm and 4am'
END

Remplacez 4 et 18 par les heures auxquelles vous souhaitez que la régénération ait lieu.
Trois fois par jour à des heures spécifiques 
SELECT CASE
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 4 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 9
    THEN 'between 4am and 9am'
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 9 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 18
    THEN 'between 9am and 6pm'
  ELSE 'between 6pm and 4am'
END

Remplacez 4, 9 et 18 par les heures auxquelles vous souhaitez que la régénération ait lieu.
Lorsqu'une table spécifique est mise à jour 
SELECT COUNT(*) FROM table
Toutes les heures 
SELECT HOUR(CURTIME())
Toutes les 2 heures (temps universel coordonné, UTC) 
SELECT FLOOR(UNIX_TIMESTAMP() / (2*60*60))

Vous pouvez remplacer le "2" par le nombre d'heures que vous souhaitez entre chaque régénération.
Ne jamais mettre à jour les données 
SELECT 1

Amazon Redshift

Programmation de régénération souhaitée SQL à utiliser
Une fois par jour à minuit 
SELECT CURRENT_DATE
Une fois par jour à une heure spécifique 
SELECT FLOOR((EXTRACT(epoch from GETDATE()) - 60*60*3)/(60*60*24))

Remplacez le "3" par l'heure à laquelle vous souhaitez que la régénération ait lieu.
Deux fois par jour à des heures spécifiques 
SELECT CASE
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 4 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 18
    THEN 'between 4am and 6pm'
  ELSE 'between 6pm and 4am'
END

Remplacez 4 et 18 par les heures auxquelles vous souhaitez que la régénération ait lieu.
Trois fois par jour à des heures spécifiques 
SELECT CASE
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 4 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 9
    THEN 'between 4am and 9am'
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 9 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 18
    THEN 'between 9am and 6pm'
  ELSE 'between 6pm and 4am'
END

Remplacez 4, 9 et 18 par les heures auxquelles vous souhaitez que la régénération ait lieu.
Lorsqu'une table spécifique est mise à jour 
SELECT COUNT(*) FROM table
Toutes les heures 
SELECT DATE_PART('hour', GETDATE())
Toutes les 2 heures 
SELECT FLOOR(EXTRACT(epoch from GETDATE()) / (2*60*60))

Vous pouvez remplacer le "2" par le nombre d'heures que vous souhaitez entre chaque régénération.
Ne jamais mettre à jour les données 
SELECT 1

PostgreSQL

Programmation de régénération souhaitée SQL à utiliser
Une fois par jour à minuit 
SELECT CURRENT_DATE
Une fois par jour à une heure spécifique 
SELECT FLOOR((EXTRACT(epoch from NOW()) - 60*60*3)/(60*60*24))

Remplacez le "3" par l'heure à laquelle vous souhaitez que la régénération ait lieu.
Deux fois par jour à des heures spécifiques 
SELECT CASE
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 4 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 18
    THEN 'between 4am and 6pm'
  ELSE 'between 6pm and 4am'
END

Remplacez 4 et 18 par les heures auxquelles vous souhaitez que la régénération ait lieu.
Trois fois par jour à des heures spécifiques 
SELECT CASE
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 4 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 9
    THEN 'between 4am and 9am'
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 9 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 18
    THEN 'between 9am and 6pm'
  ELSE 'between 6pm and 4am'
END

Remplacez 4, 9 et 18 par les heures auxquelles vous souhaitez que la régénération ait lieu.
Lorsqu'une table spécifique est mise à jour 
SELECT COUNT(*) FROM table
Toutes les heures 
SELECT DATE_PART('hour', NOW())
Toutes les 2 heures 
SELECT FLOOR(EXTRACT(epoch from NOW()) / (2*60*60))

Vous pouvez remplacer le "2" par le nombre d'heures que vous souhaitez entre chaque régénération.
Ne jamais mettre à jour les données 
SELECT 1

Snowflake

Programmation de régénération souhaitée SQL à utiliser
Une fois par jour à minuit 
SELECT CURRENT_DATE()
Une fois par jour à une heure spécifique (temps universel coordonné, UTC) 
SELECT FLOOR((DATE_PART('EPOCH_SECOND', CURRENT_TIMESTAMP) - 60*60*3)/(60*60*24))

Remplacez le "3" par l'heure à laquelle vous souhaitez que la régénération ait lieu.
Deux fois par jour à des heures spécifiques 
SELECT CASE
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 4 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 18
    THEN 'between 4am and 6pm'
  ELSE 'between 6pm and 4am'
END

Remplacez 4 et 18 par les heures auxquelles vous souhaitez que la régénération ait lieu.
Trois fois par jour à des heures spécifiques 
SELECT CASE
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 4 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 9
    THEN 'between 4am and 9am'
  WHEN EXTRACT(HOUR FROM CURRENT_TIMESTAMP) > 9 AND EXTRACT(HOUR FROM CURRENT_TIMESTAMP) < 18
    THEN 'between 9am and 6pm'
  ELSE 'between 6pm and 4am'
END

Remplacez 4, 9 et 18 par les heures auxquelles vous souhaitez que la régénération ait lieu.
Lorsqu'une table spécifique est mise à jour 
SELECT COUNT(*) FROM table
Toutes les heures 
SELECT HOUR(CURRENT_TIME())
Toutes les 2 heures (temps universel coordonné, UTC) 
SELECT FLOOR(DATE_PART('EPOCH_SECOND', CURRENT_TIMESTAMP) / (2*60*60))

Vous pouvez remplacer le "2" par le nombre d'heures que vous souhaitez entre chaque régénération.
Ne jamais mettre à jour les données 
SELECT 1

Difficultés courantes

sql_trigger_value nécessite que vous ayez configuré des tables dérivées persistantes

L'utilisation de sql_trigger_value génère des erreurs de validation LookML, sauf si vous avez activé la persistance pour les tables dérivées dans les paramètres de connexion à votre base de données. La plupart des clients configurent des tables dérivées persistantes lorsqu'ils configurent initialement une connexion à une base de données. L'exception la plus courante à cette règle concerne les clients qui connectent Looker à une base de données PostgreSQL secondaire en lecture seule et à chaud.

sql_trigger_value fonctionne différemment en mode Développement et en mode Production

sql_trigger_value devrait fonctionner comme prévu en mode Production. En mode Développement, toutes les tables dérivées sont traitées comme si persist_for: 24 hours avait été utilisé, quel que soit le paramètre que vous avez implémenté. Pour en savoir plus, consultez la section Tables persistantes en mode Développement de la page de documentation Tables dérivées dans Looker.