sql_trigger_value

Utilisation

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

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

Définition

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 streaming de charger des ensembles de résultats volumineux 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 planification selon vos besoins à l'aide du paramètre PDT And Datagroup Maintenance Schedule (Planification de la maintenance des TPD 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 sql_trigger_value
2015-01-01 00:00 01-01-2015
2015-01-01 00:05 01-01-2015
2015-01-01 00:10 01-01-2015
… …
2015-01-01 23:55 01-01-2015
2015-01-02 00:00 2015-01-02
2015-01-02 00:05 2015-01-02

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

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 ne soit modifiée. Sélectionnez l'option Reconstruire les tables dérivées et exécuter dans le menu en forme de roue dentée Actions sur les explorations après avoir exécuté une requête.

Pour en savoir plus sur l'option Recréer 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 recrée 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 présentent le code SQL à utiliser pour différentes stratégies de régénération des PDT sur différents dialectes :

Google BigQuery

Planification 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 précise
SELECT FLOOR(((TIMESTAMP_DIFF(CURRENT_TIMESTAMP(),'1970-01-01 00:00:00',SECOND)) - 60*60*3)/(60*60*24))

Remplacez "3" par l'heure de la journée à 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 de la journée 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 de la journée 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 "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

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

Remplacez "3" par l'heure de la journée à 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 de la journée 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 de la journée 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 deux heures (temps universel coordonné, UTC)
SELECT FLOOR(UNIX_TIMESTAMP() / (2*60*60))

Vous pouvez remplacer "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

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

Remplacez "3" par l'heure de la journée à 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 de la journée 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 de la journée 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 "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

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

Remplacez "3" par l'heure de la journée à 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 de la journée 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 de la journée 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 "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

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

Remplacez "3" par l'heure de la journée à 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 de la journée 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 de la journée 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 deux heures (temps universel coordonné, UTC)
SELECT FLOOR(DATE_PART('EPOCH_SECOND', CURRENT_TIMESTAMP) / (2*60*60))

Vous pouvez remplacer "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 entraînera des erreurs de validation LookML, sauf si vous avez activé la persistance pour les tables dérivées dans les paramètres de connexion de 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 à un serveur secondaire PostgreSQL en lecture seule et remplaçable à 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.