Cette page a été traduite par l'API Cloud Translation.

Documentation de référence sur le langage de requête (version 0.7)

Le langage de requête de l'API Google Visualization vous permet d'effectuer diverses manipulations de données avec la requête à la source de données.

Sommaire

Introduction
Utiliser le langage de requête
1. Définir la requête à partir de JavaScript
2. Définir la requête dans l'URL de la source de données
Syntaxe du langage

Présentation

En règle générale, les visualisations attendent des données sous une forme spécifique. Par exemple, un graphique à secteurs peut attendre des données sous la forme de deux colonnes: un libellé de texte et une valeur numérique. Les données de la source de données peuvent ne pas correspondre exactement à cette structure. Par exemple, la source de données peut avoir plus de deux colonnes, ou l'ordre des colonnes peut ne pas correspondre à l'ordre attendu dans le graphique à secteurs.

Le langage de requête permet d'envoyer des requêtes de manipulation et de mise en forme de données à la source de données, et de s'assurer que la structure et le contenu des données renvoyées correspondent à la structure attendue.

La syntaxe du langage de requête est semblable à SQL. Les développeurs qui maîtrisent SQL doivent pouvoir apprendre et utiliser rapidement ce langage de requête. De nombreux tutoriels SQL sont disponibles sur le Web. Il existe des différences entre ce langage de requête et SQL, qui sont décrites dans la section Syntaxe.

Notez que les sources de données ne sont pas obligées d'implémenter le langage de requête ni, le cas échéant, d'implémenter toutes les fonctionnalités de ce langage. Sauf indication contraire de votre part, vous ne devez pas dépendre d'une source de données pour mettre en œuvre toutes les fonctionnalités de ce langage.

Utiliser le langage de requête

Vous pouvez associer une chaîne de requête à une requête de source de données de deux manières: en définissant la chaîne de requête à partir du code JavaScript ou en définissant la chaîne de requête comme paramètre dans l'URL de la source de données. Si votre requête n'inclut pas de chaîne de requête, le comportement par défaut d'une source de données consiste à renvoyer toutes les lignes et colonnes en utilisant l'ordre et la mise en forme par défaut. Vous pouvez la modifier en incluant une chaîne de requête dans votre requête à une source de données.

Définir la requête à partir de JavaScript

Pour définir la chaîne de requête à partir du code JavaScript, appelez la méthode setQuery de la classe google.visualization.Query.

var query = new google.visualization.Query(DATA_SOURCE_URL);
query.setQuery('select dept, sum(salary) group by dept');
query.send(handleQueryResponse);

Définir la requête dans l'URL de la source de données

Vous pouvez ajouter la chaîne de requête à l'URL de la source de données à l'aide du paramètre tq. Définir la requête dans le paramètre d'URL plutôt que dans JavaScript vous permet d'utiliser facilement des visualisations écrites par d'autres développeurs, tout en ayant la possibilité de la personnaliser.

La chaîne de requête doit être correctement encodée en tant que paramètre d'URL. Vous pouvez encoder une URL à l'aide de la fonction JavaScript encodeURIComponent ou l'encoder manuellement, à l'aide de l'outil fourni à la fin de cette section.

Exemple :

Prenons la chaîne de requête suivante pour une feuille de calcul Google. Notez que les ID de colonne dans les feuilles de calcul sont toujours composés de lettres. Le texte des en-têtes de colonne dans la feuille de calcul publiée est des libellés, et non des ID. Vous devez utiliser l'ID, et non le libellé, dans votre chaîne de requête.

select A, sum(B) group by A

Une fois encodée, cette requête devient:

select%20A%2C%20sum(B)%20group%20by%20A

Supposons qu'il s'agit de l'URL de votre feuille de calcul:

https://docs.google.com/a/google.com/spreadsheets/d/1r8_mfnZAvTFmT02JHi1XgOwn_-sLCR9XgmR8wEQ4uW4

Ajoutez /gviz/tq?tq=YOUR_QUERY_STRING à l'URL de la feuille de calcul pour obtenir votre chaîne de requête finale:

https://docs.google.com/a/google.com/spreadsheets/d/1r8_mfnZAvTFmT02JHi1XgOwn_-sLCR9XgmR8wEQ4uW4/gviz/tq?tq=select%A%2C%20sum(B)%20group%20by%20A

Utilisez l'outil ci-dessous pour encoder ou décoder une chaîne de requête:

Remarque:Pour accéder aux données d'une feuille de calcul privée, vous devez transmettre des identifiants d'autorisation explicites à l'aide du protocole OAuth. Pour en savoir plus, consultez la section Autorisation : feuilles de calcul Google.

Syntaxe du langage

Présentation

La syntaxe du langage de requête de l'API Google Visualization est semblable à la syntaxe SQL. Cependant, il s'agit d'un sous-ensemble de SQL, avec quelques caractéristiques propres que vous devrez apprendre. Si vous connaissez bien SQL, il n'y a rien de plus simple.

Tables de données

Ce document fait référence au tableau de données pour désigner l'ensemble de résultats d'une requête. Un tableau de données est composé de lignes et de colonnes. Chaque colonne d'un tableau de données possède les propriétés suivantes:

Identifiant (ou ID de colonne). Utilisé pour référencer des colonnes dans la requête. Notez que vous ne devez jamais essayer de référencer une colonne par libellé dans une requête, mais uniquement par identifiant. Conseil:Essayez de ne pas utiliser d'ID incluant des espaces, car les espaces sont difficiles à gérer et peuvent entraîner des erreurs (petites, mais difficiles à trouver) dans votre codage. En outre, les ID contenant des espaces doivent être entourés par des guillemets.
Label (Libellé). string qui s'affiche généralement pour les utilisateurs finaux. (par exemple, une légende dans un graphique à secteurs ou un en-tête de colonne dans un tableau).
Type de données : Les types de données compatibles sont string, number, boolean, date, datetime et timeofday. Toutes les valeurs d'une colonne ont un type de données correspondant au type de colonne ou une valeur null. Ces types sont semblables, mais pas identiques, aux types JavaScript décrits dans la section Littéraux de cette page.
Modèle de mise en forme. La source de données peut définir des modèles de mise en forme pour certaines ou toutes ses colonnes. Vous pouvez ignorer ce modèle en incluant une clause de format.

Tableau utilisé dans tous les exemples:

Dans cette section, tous les exemples de requêtes font référence au tableau suivant. Les en-têtes de colonne sont les identifiants des colonnes.

nom `string`	dept `string`	Déjeuner `timeofday`	salaire `number`	date d'embauche `date`	âge `number`	Senior `boolean`	seniorityStartTime `datetime`
Jean	Eng	12:00:00	1000	2005-03-19	35	true	02-12-2007 15:56:00
Dave	Eng	12:00:00	500	2006-04-19	27	false	nul
Sally	Eng	13:00:00	600	2005-10-10	30	false	nul
Ben	Ventes	12:00:00	400	2002-10-10	32	true	09-03-2005 12:30:00
Dana	Ventes	12:00:00	350	2004-09-08	25	false	nul
Mike	Marketing	13:00:00	800	2005-01-10	24	true	30-12-2007 14:40:00

Clauses linguistiques

La syntaxe du langage de requête est composée des clauses suivantes. Chaque clause commence par un ou deux mots clés. Toutes les clauses sont facultatives. Les clauses sont séparées par des espaces. Les clauses doivent être présentées dans l'ordre suivant:

Clause	Utilisation
`select`	Sélectionne les colonnes à afficher et dans quel ordre. En cas d'omission, toutes les colonnes de la table sont renvoyées, dans leur ordre par défaut.
`where`	Renvoie seulement les lignes qui correspondent à une condition. En cas d'omission, toutes les lignes sont renvoyées.
`group by`	Agrège les valeurs des lignes.
`pivot`	Transforme les valeurs distinctes des colonnes en nouvelles colonnes.
`order by`	Trie les lignes par valeurs dans les colonnes.
`limit`	Limite le nombre de lignes renvoyées.
`offset`	Ignore un certain nombre de premières lignes.
`label`	Définit des libellés de colonne.
`format`	Formate les valeurs de certaines colonnes en utilisant des modèles de mise en forme spécifiques.
`options`	Définit des options supplémentaires.
`from`	La clause `from` a été éliminée de la langue.

Sélectionner

La clause select permet de spécifier les colonnes à renvoyer et leur ordre. Si cette clause n'est pas spécifiée ou si select * est utilisé, toutes les colonnes de la table de source de données sont renvoyées, dans leur ordre d'origine. Les colonnes sont référencées par des identifiants (et non par des libellés). Par exemple, dans une feuille de calcul Google, les identifiants de colonne sont composés d'une ou de deux lettres de colonne de caractères (A, B, C, etc.).

Les éléments d'une clause select peuvent être des identifiants de colonne, ou le résultat des fonctions d'agrégation, des fonctions scalaires ou des opérateurs.

Exemples :

select *

select dept, salary

select max(salary)

Dans l'exemple suivant, les guillemets précédents sont utilisés pour référencer des ID de colonne contenant des espaces (adresse e-mail) ou des mots réservés (date):

select `email address`, name, `date`

Exécuter la requête suivante sur l'exemple de table :

select lunchTime, name

Renvoie la réponse suivante:

déjeuner	name (nom)
12:00:00	Jean
12:00:00	Dave
13:00:00	Sally
12:00:00	Ben
12:00:00	Dana
13:00:00	Mike

Où ?

La clause where permet de ne renvoyer que les lignes qui correspondent à une condition spécifiée.

Les opérateurs de comparaison simples sont <=, <, >, >=, =, !=, <>. Les deux opérateurs de comparaison != <> signifient "différent de". Les chaînes sont comparées par valeur lexicographique. Notez que l'égalité est indiquée par =, et non par ==, comme dans la plupart des langages informatiques. La comparaison avec null s'effectue à l'aide de is null ou de is not null.

Vous pouvez joindre plusieurs conditions à l'aide des opérateurs logiques and, or et not. Les parenthèses permettent de définir une priorité explicite.

La clause WHERE accepte également des opérateurs de comparaison de chaînes plus complexes. Ces opérateurs prennent deux chaînes comme arguments. Tous les arguments autres que des chaînes (par exemple, les dates ou les nombres) seront convertis en chaînes avant la comparaison. La mise en correspondance de chaînes est sensible à la casse (vous pouvez utiliser des fonctions scalaires upper() ou lower() pour contourner ce problème).

contains : correspondance de sous-chaîne. Toute contains part est vraie si part est n'importe où dans entier. Exemple : where name contains 'John' correspond à "John", "John Adams", "Long John Silver", mais pas à "john adams".
starts with : correspondance de préfixe. value starts with prefix est vrai si prefix est au début de value. Exemples:where dept starts with 'engineering' correspond à "engineering" (ingénierie) et "engineering managers" (responsables de l'ingénierie). where dept starts with 'e' correspond à "engineering", "eng" et "e".
ends with : correspondance de suffixe. valeur ends with suffixe est "true" si suffix est situé à la fin de value. Exemple:where role ends with 'y' correspond à 'cowboy', 'boy' et 'y'.
matches : correspondance d'expression régulière (preg). haystack matches needle est "true" si l'expression régulière dans needle correspond à haystack. Exemples:where country matches '.*ia' correspond à l'Inde et au Nigeria, mais pas à l'Indiana. Notez qu'il ne s'agit pas d'une recherche globale. Par conséquent, where country matches 'an' ne correspondra pas à "Canada".
like : recherche de texte prenant en charge deux caractères génériques : %, qui correspond à zéro ou plusieurs caractères de tous types, et _ (trait de soulignement), qui correspond à n'importe quel caractère. Cet opérateur est semblable à l'opérateur SQL LIKE. Exemple:where name like fre% correspond à "fre", "fred" et "freddy".

Exemples :

where salary >= 600
where dept != 'Eng' and date '2005-01-21' < hireDate
where (dept<>'Eng' and isSenior=true) or (dept='Sales') or seniorityStartTime is null

Exécuter la requête suivante sur l'exemple de table:

select name where salary > 700

Renvoie la réponse suivante:

name (nom)
Jean
Mike

Grouper par

La clause group by permet d'agréger des valeurs sur plusieurs lignes. Une seule ligne est créée pour chaque combinaison distincte de valeurs dans la clause de regroupement. Les données sont automatiquement triées en fonction des colonnes de regroupement, sauf indication contraire dans une clause order by.

Remarque:Si vous utilisez une clause group by, chaque colonne répertoriée dans la clause select doit être répertoriée dans la clause group by ou encapsulée par une fonction d'agrégation.

Exemples :

select dept, max(salary) group by dept

Exécuter la requête suivante sur l'exemple de table:

select lunchTime, avg(salary), count(age) group by isSenior,lunchTime

Renvoie la réponse suivante:

déjeuner	salaire moy.	nombre-âge
12:00:00	425	2
13:00:00	600	1
12:00:00	700	2
13:00:00	800	1

Pivot

La clause pivot permet de transformer les valeurs distinctes des colonnes en nouvelles colonnes. Par exemple, un tableau croisé dynamique associé à une colonne "année" génère une table avec une colonne pour chaque année distincte qui apparaît dans le tableau d'origine. Cela peut être utile si, par exemple, une visualisation de graphique en courbes trace chaque colonne sous la forme d'une ligne distincte. Si vous souhaitez tracer une ligne distincte pour chaque année et que "année" est l'une des colonnes du tableau d'origine, une bonne option consiste à utiliser une opération de tableau croisé dynamique pour effectuer la transformation de données nécessaire.

Remarque:Si vous utilisez une clause pivot, chaque colonne répertoriée dans la clause select doit être répertoriée dans la clause group by ou encapsulée par une fonction d'agrégation.

Étant donné que plusieurs lignes peuvent contenir les mêmes valeurs pour les colonnes de tableaux croisés dynamiques, le tableau croisé dynamique implique une agrégation. Notez que lorsque vous utilisez pivot sans group by, la table de résultats contient exactement une ligne. Par exemple, en exécutant la requête suivante sur l'exemple de table:

select sum(salary) pivot dept

Renvoie la réponse suivante:

Salaire des ingénieurs	Somme marketing-salaire	Somme des ventes
2100	800	750

En effet, la somme de 2 100 correspond à la somme des salaires du département Eng, de 800 au département Marketing, etc.

Il peut être encore plus utile d'utiliser pivot avec group by, car cela crée une table dans laquelle chaque cellule contient le résultat de l'agrégation pour la ligne et la colonne correspondantes. Par exemple, en exécutant la requête suivante sur l'exemple de table :

select dept, sum(salary)
  group by dept
  pivot lunchTime

Renvoie la réponse suivante:

dept	12:00:00 somme-salaire	13:00:00 somme-salaire
Eng	1 500	600
Marketing	nul	800
Ventes	750	nul

Vous pouvez également "inverser" cette table, changer de colonne et de ligne, en passant des colonnes pivot aux colonnes group by. Exécutez la requête suivante sur l'exemple de table :

select lunchTime, sum(salary)
  group by lunchTime
  pivot dept

Renvoie la réponse suivante:

déjeuner	Salaire des ingénieurs	Somme marketing-salaire	Somme des ventes
12:00:00	1 500	nul	750
13:00:00	600	800	nul

Vous pouvez également utiliser plusieurs colonnes dans la clause pivot. Dans ce cas, les colonnes de la table de réponse sont composées de toutes les combinaisons de valeurs uniques des colonnes qui existent dans la table d'origine. Par exemple, exécutez la requête suivante sur l'exemple de table:

select sum(salary)
  pivot dept, lunchTime

Renvoie la réponse suivante:

Eng,12:00:00 Somme-salaire	13:00:00 Somme-salaire	Marketing,13:00:00 somme-salaire	Ventes,12:00:00 Salaire
1 500	600	800	750

Notez que seules les combinaisons qui apparaissent dans la table d'origine se voient attribuer des colonnes dans la table de réponse. C'est la raison pour laquelle il n'y a pas de colonne pour Marketing,12:00:00 ni pour Ventes,13:00:00.

Il est également possible d'utiliser plusieurs agrégations. Par exemple, en exécutant la requête suivante sur l'exemple de table :

select sum(salary), max(lunchTime)
  pivot dept

Renvoie la réponse suivante:

Salaire des ingénieurs	Somme marketing-salaire	Somme des ventes	Eng max-lunchTime	Marketing max-lunchTime	Ventes max-lunchTime
2100	800	750	13:00:00	13:00:00	12:00:00

Vous pouvez combiner plusieurs agrégations dans la clause select, plusieurs colonnes dans la clause group by et plusieurs colonnes dans la clause pivot. En interne, l'agrégation est effectuée par la concaténation des colonnes de l'entité de regroupement et par les clauses de tableau croisé dynamique.

Les colonnes spécifiées dans la clause pivot peuvent ne pas apparaître dans les clauses select, group by ou order by. Lorsque pivot est utilisé, la clause order by ne peut contenir aucune colonne d'agrégation. En effet, pour chaque agrégation spécifiée dans la clause select, de nombreuses colonnes sont générées dans la table de résultats. Toutefois, vous pouvez mettre en forme les colonnes d'agrégation lorsque pivot est utilisé. Ce format permet de formater toutes les nouvelles colonnes pertinentes à l'agrégation spécifique, générées par l'opération de tableau croisé dynamique, selon le modèle spécifié. Dans l'exemple ci-dessus, l'ajout de format sum(salary) "some_format_string" aura une incidence sur les colonnes suivantes: Somme Eng, Salaire marketing et Somme des ventes.

Vous pouvez attribuer un libellé aux colonnes d'agrégation. Si aucun libellé n'est spécifié dans la clause label, le libellé d'une colonne résultant d'un tableau croisé dynamique est composé de la liste des valeurs des colonnes, du type d'agrégation (min, max, sum, ...) et du libellé de la colonne agrégée. Exemple : "Eng,12:00:00 Somme Salaire". Si une seule agrégation a été spécifiée dans la clause select, la partie d'agrégation est supprimée du libellé, et seule la liste des valeurs des colonnes pivots est conservée. Exemple : "Eng,12:00:00". Lorsqu'une clause label spécifie un libellé pour une colonne d'agrégation, le libellé demandé est ajouté à la liste des valeurs, à la fois lorsqu'il n'y a qu'une agrégation dans la clause select et lorsqu'il y en a plusieurs. Par exemple, label sum(salary) "sumsal" donnera les étiquettes de colonne "Eng,12:00:00 sumsal", "Eng,13:00:00 sumsal", etc.

Trier par

La clause order by permet de trier les lignes en fonction des valeurs des colonnes spécifiées.

Les éléments d'une clause order by peuvent être des identifiants de colonne, ou la sortie des fonctions d'agrégation, des fonctions scalaires ou des opérateurs.

Exemples :

order by dept, salary desc

select dept, max(salary) group by dept order by max(salary)

Limite

La clause limit permet de limiter le nombre de lignes renvoyées.

Exemple :

limit 100

Décalage

La clause offset permet d'ignorer un nombre donné de premières lignes. Si une clause limit est utilisée, offset est appliqué en premier. Par exemple, limit 15 offset 30 renvoie les lignes 31 à 45.

Exemples :

offset 10
limit 30 offset 210

Libellé

La clause label permet de définir le libellé d'une ou de plusieurs colonnes. Notez que vous ne pouvez pas utiliser une valeur de libellé à la place d'un ID dans une requête.

Les éléments d'une clause label peuvent être des identifiants de colonne, ou la sortie des fonctions d'agrégation, des fonctions scalaires ou des opérateurs.

Syntaxe :

label column_id label_string [,column_id label_string]

column_id: : identifiant de la colonne auquel le libellé est attribué.
label_string: Libellé à attribuer à cette colonne. De nombreuses visualisations utilisent le libellé de colonne en tant que texte à présenter à l'utilisateur final, comme un libellé de légende dans un graphique à secteurs. Les étiquettes sont des littéraux de chaîne et suivent ces règles de syntaxe.

Exemple :

Dans l'exemple suivant, le libellé de la colonne "dept" est défini sur "Department" (Département), le libellé de la colonne "name" (Nom de l'employé) et le libellé de la colonne "location" (Emplacement) sur "Employee Location" (Emplacement de l'employé) :

label dept 'Department', name "Employee Name", location 'Employee Location'

Format

La clause format permet de spécifier une valeur mise en forme pour les cellules d'une ou de plusieurs colonnes. Les données renvoyées doivent inclure à la fois une valeur réelle et une valeur formatée pour chaque cellule d'une colonne formatée. De nombreuses visualisations utilisent la valeur non formatée pour les calculs, mais la valeur formatée pour l'affichage. Les modèles que vous spécifiez dans cette clause sont généralement renvoyés dans la propriété pattern des colonnes correspondantes.

Syntaxe du modèle:

number, date, timeofday, datetime: Les formats de date et de nombre définis par l'ICU.
boolean: Le format est un string au format value-if-true:value-if-false.

Exemple :

format salary '#,##0.00', hireDate 'dd-MMM-yyyy', isSenior 'Yes!:Not yet'

Options

La clause options permet de contrôler des options supplémentaires pour l'exécution de requêtes. Les mots clés possibles qui peuvent suivre la clause options sont les suivants:

no_format Supprime les valeurs formatées du résultat et ne conserve que les valeurs sous-jacentes. Peut être utilisée lorsque la visualisation spécifique n'utilise pas les valeurs formatées pour réduire la taille de la réponse.
no_values Supprime les valeurs sous-jacentes du résultat et ne conserve que les valeurs formatées. Peut être utilisée lorsque la visualisation spécifique n'utilise que les valeurs formatées pour réduire la taille de la réponse.

Fonctions de manipulation de données

Plusieurs types d'opérateurs et de fonctions vous permettent de manipuler ou d'agréger des données dans une seule colonne, ou de comparer ou de combiner des données entre des colonnes. Exemples : sum() (pour ajouter toutes les valeurs d'une colonne), max (pour trouver la valeur la plus élevée dans une colonne) et + (pour ajouter les valeurs de deux colonnes ensemble sur la même ligne).

Certaines fonctions peuvent apparaître dans n'importe quelle clause, d'autres dans un sous-ensemble de clauses. Ce processus est décrit ci-dessous.

Exemple :

Compte tenu de ce tableau...

Si nous appliquons cette requête...

Nous obtenons ce résultat.

Nom	Salaire	Taxes	StartDate
Sharon	1000	100	01/01/2009
Avital	2 000	200	21/01/2008
Moran	3 000	300	12/02/2008

select upper(name), year(startDate)

Nom	year(StartDate) :
AVITAL	2008
MORAN	2008
SHARON	2009

Les fonctions de manipulation de données suivantes sont définies par le langage de requête de l'API Google Visualization:

Fonctions d'agrégation
Fonctions scalaires
Opérateurs arithmétiques

Fonctions d'agrégation

Les fonctions d'agrégation reçoivent un identifiant de colonne et effectuent une action sur toutes les valeurs de chaque groupe (les groupes sont spécifiés par les clauses group by ou pivot, ou toutes les lignes si ces clauses ne sont pas utilisées).

Exemples :

select max(salary)               // Returns a table with one column and one row.
select max(salary) group by dept // Returns a table with the max salary for each dept column value.
select max(salary) pivot dept    // Returns a one-row table with a column for each dept,
                                 //   and the max salary for that department.

Les fonctions d'agrégation peuvent être utilisées dans les clauses select, order by, label et format. Elles ne peuvent pas apparaître dans les clauses where, group by, pivot, limit, offset ou options.

Voici les fonctions d'agrégation acceptées:

Nom	Description	Types de colonnes acceptés	Type renvoyé
`avg()`	Renvoie la valeur moyenne de toutes les valeurs de la colonne pour un groupe.	`number`	`number`
`count()`	Renvoie le nombre d'éléments dans la colonne spécifiée pour un groupe. Les cellules nulles ne sont pas comptabilisées.	Tous les types	`number`
`max()`	Renvoie la valeur maximale de la colonne pour un groupe. Les dates sont comparées aux dates antérieures, tandis que les valeurs `string` sont classées par ordre alphabétique selon la sensibilité à la casse.	Tous les types	Même type que la colonne
`min()`	Affiche la valeur minimale de la colonne pour un groupe. Les dates sont comparées à des dates antérieures, les valeurs `string` sont classées par ordre alphabétique et la sensibilité à la casse	Tous les types	Même type que la colonne
`sum()`	Renvoie la somme de toutes les valeurs de la colonne pour un groupe.	`number`	`number`

Remarque:Les fonctions d'agrégation ne peuvent utiliser qu'un identifiant de colonne en tant qu'argument:

max(startDate)                      // OK
min(firstScore) + min(secondScore)  // OK
max(year(startDate))                // INVALID. max requires column ID
sum(salary + perks)                 // INVALID. sum requires column ID.

Fonctions scalaires

Les fonctions scalaires fonctionnent sur zéro ou plusieurs paramètres pour produire une autre valeur. Les fonctions scalaires peuvent être transmises à toute expression qui renvoie le paramètre du type approprié. Notez que ces types sont définis dans la section Literals de ce document, qui peuvent être légèrement différents des objets JavaScript portant un nom similaire.

Notez que vous modifierez le nom de la colonne en l'encapsulant avec une fonction scalaire.

Les fonctions scalaires peuvent utiliser comme paramètre tout élément évalué sur une valeur unique:

year(max(startDate))
datediff(now(), todate(1234567890000))

Les fonctions scalaires peuvent être utilisées dans n'importe laquelle des clauses suivantes: select, where, group by, pivot, order by, label, et format.

Nom
`year()`	Renvoie la valeur d'année à partir d'une valeur de date ou de date/heure. Par exemple, `year(date "2009-02-05")` renvoie 2009. Paramètres:un paramètre de type `date` ou `datetime` Type de retour: `number`
`month()`	Renvoie la valeur du mois de base zéro à partir d'une date ou d'une date et d'heure. Par exemple, `month(date "2009-02-05")` renvoie 1. Remarque: Les mois sont au nombre 0. Par conséquent, la fonction renvoie 0 pour janvier, 1 pour février, etc. Paramètres : un paramètre de type `date` ou `datetime` Type de retour : `number`
`day()`	Renvoie le jour du mois à partir d'une valeur `date` ou datetime. Par exemple, `day(date "2009-02-05")` renvoie 5. Paramètres : un paramètre de type `date` ou `datetime` Type de retour: `number`
`hour()`	Renvoie la valeur d'heure à partir d'une valeur date/heure ou `timeofday`. Par exemple, `hour(timeofday "12:03:17")` renvoie 12. Paramètres : un paramètre de type `datetime` ou `timeofday` Type de retour: `number`
`minute()`	Renvoie la valeur des minutes à partir d'une valeur `datetime` ou `timeofday`. Par exemple, `minute(timeofday "12:03:17")` renvoie 3. Paramètres : un paramètre de type `datetime` ou `timeofday` Type de retour: `number`
`second()`	Renvoie la deuxième valeur d'une valeur `datetime` ou `timeofday`. Par exemple, `second(timeofday "12:03:17")` renvoie 17. Paramètres : un paramètre de type `datetime` ou `timeofday` Type de retour : `number`
`millisecond()`	Renvoie la partie milliseconde d'une valeur `datetime` ou `timeofday`. Par exemple, `millisecond(timeofday "12:03:17.123")` renvoie 123. Paramètres : un paramètre de type `datetime` ou `timeofday` Type de retour: `number`
`quarter()`	Renvoie le trimestre à partir d'une valeur `date` ou `datetime`. Par exemple, `quarter(date "2009-02-05")` renvoie 1. Notez que les quarts sont basés sur un 1. La fonction renvoie donc 1 pour le premier quart, 2 pour le deuxième, etc. Paramètres : un paramètre de type `date` ou `datetime` Type de retour: `number`
`dayOfWeek()`	Renvoie le jour de la semaine à partir d'une valeur `date` ou `datetime`. Par exemple, `dayOfWeek(date "2009-02-26")` renvoie 5. Notez que les jours sont en base 1. La fonction renvoie donc 1 pour dimanche, 2 pour lundi, etc. Paramètres:un paramètre de type `date` ou `datetime` Type de retour: `number`
`now()`	Renvoie une valeur "datetime" représentant la valeur `datetime` actuelle dans le fuseau horaire GMT. Paramètres:aucun Type de retour: `datetime`
`dateDiff()`	Renvoie la différence en jours entre deux valeurs `date` ou `datetime`. Remarque: Seules les parties `date` des valeurs sont utilisées dans le calcul. La fonction renvoie donc toujours une valeur entière. Par exemple, `dateDiff(date "2008-03-13", date "2008-02-12")` renvoie 29 ; `dateDiff(date "2009-02-13", date "2009-03-13")` renvoie -29. Les valeurs temporelles sont tronquées avant la comparaison. Paramètres : deux paramètres de type `date` ou `datetime` (tous deux autorisés) Type de retour : `number`
`toDate()`	Transforme la valeur donnée en une valeur `date`. Avec une valeur `date`, il renvoie la même valeur. Pour une valeur `datetime` donnée, il renvoie la partie `date`. Par exemple, `toDate(dateTime "2009-01-01 12:00:00")` renvoie "2009-01-01". Pour un `number` N, la fonction renvoie un `date` N milliseconde après l'epoch. L'époque correspond à la date du 1er janvier 1970 à 00:00:00 GMT. Par exemple, `toDate(1234567890000)` renvoie "2009-02-13". Paramètres : un paramètre de type `date`, `datetime` ou `number` Type de retour: `date`
`upper()`	Renvoie le `string` donné en majuscules. Par exemple, `upper("foo")` renvoie "FOO". Paramètres : un paramètre de type `string` Type de retour : `string`
`lower()`	Renvoie le `string` donné en minuscules. Par exemple, `lower("Bar")` renvoie "bar". Paramètres:un paramètre de type `string` Type de retour: `string`

Opérateurs arithmétiques

Vous pouvez utiliser des opérateurs arithmétiques pour effectuer des opérations mathématiques sur tout élément qui aboutit à un seul nombre (qui correspond à la sortie des fonctions d'agrégation, des opérateurs ou des constantes appropriées).

Exemples :

select empSalary - empTax
select 2 * (max(empSalary) / max(empTax))

Les opérateurs suivants sont définis:

Nom	Description	Paramètres	Type renvoyé
`+`	Renvoie la somme de deux valeurs `number`.	Deux `number`	`number`
`-`	Renvoie la différence entre deux valeurs `number`.	Deux `number`	`number`
`*`	Renvoie le produit de deux valeurs `number`.	Deux `number`	`number`
`/`	Renvoie le quotient de deux valeurs `number`. La division par zéro renvoie la valeur null.	Deux `number`	`number`

Éléments linguistiques

Littéraux

Les littéraux sont des valeurs utilisées pour les comparaisons ou les attributions. Les littéraux peuvent être des valeurs string, des nombres, des valeurs booléennes ou différents types de date/heure. Voici quelques exemples de littéraux utilisés dans la syntaxe des requêtes:

where startDate < date "2008-03-18"  // date "2008-03-18" is a date literal
limit 30                             // 30 is a numeric literal
format salary '#,##0.00', isSenior 'not yet:of course!'  // '#,##0.00' and 'not yet:of course!' are both string literals

Voici les formats pour chaque type de littéral:

string: Un littéral string doit être placé entre guillemets simples ou doubles. Exemples:"fourteen" 'hello world' "It's raining".
number: Les valeurs littérales numériques sont spécifiées en notation décimale. Exemples: 3 3.0 3.14 -71 -7.2 .6
boolean: Les littéraux booléens sont true ou false.
date: Utilisez le mot clé date suivi d'un littéral string au format yyyy-MM-dd. Exemple:date "2008-03-18".
timeofday: Utilisez le mot clé timeofday suivi d'un littéral string au format HH:mm:ss[.SSS]Exemple:timeofday "12:30:45".
datetime: Date et heure, avec le mot clé datetime ou le mot clé timestamp suivi d'un littéral string au format yyyy-MM-dd HH:mm:ss[.sss]. Exemple : datetime '2008-03-18 12:30:34.123'

Identifiants

Les identifiants (ou ID) sont des éléments de texte string qui identifient les colonnes.

Important:Si votre identifiant

Dispose d'espaces,
est un mot réservé ;
contient tout sauf des caractères alphanumériques ou des traits de soulignement ([a-zA-Z0-9_]) ; ou
Commence par un chiffre

il doit être entouré de guillemets.

Dans le cas contraire, il n'est pas nécessaire de mettre votre identifiant entre guillemets. Notez que tous les mots clés définis par la syntaxe ne sont pas des mots réservés. Ainsi, vous pouvez, par exemple, utiliser "max" comme identifiant, sans avoir à le mettre entre guillemets.

Exemples:col1 employee_table `start date` `7 days traffic` `select`

Nous déconseillons de choisir un identifiant nécessitant des guillemets droits, car il peut être facile d'oublier d'utiliser les guillemets précédents ou d'utiliser accidentellement des "guillemets simples" au lieu de "guillemets précédents". Il s'agit d'erreurs courantes et souvent difficiles à déboguer.

Sensibilité à la casse

Les identifiants et les littéraux de chaîne sont sensibles à la casse. Tous les autres éléments linguistiques ne sont pas sensibles à la casse.

Mots réservés

Les mots réservés suivants doivent être placés entre guillemets en cas d'utilisation d'un identifiant :

and
asc
by
date
datetime
desc
false
format
group
label
limit
not
offset
options
or
order
pivot
select
timeofday
timestamp
true
where