Langage Q - Requêtes fonctionnelles

Les requêtes fonctionnelles (dynamiques) permettent de spécifier des noms de colonnes sous forme de symboles dans des colonnes q-sql de sélection / exécution / suppression typiques. Cela est très pratique lorsque nous voulons spécifier des noms de colonnes de manière dynamique.

Les formes fonctionnelles sont -

?[t;c;b;a]    / for select
![t;c;b;a]    / for update

  • t est une table;

  • a est un dictionnaire d'agrégats;

  • bla par-phrase; et

  • c est une liste de contraintes.

Remarque -

  • Tout q entités dans a, b, et c doit être référencé par son nom, c'est-à-dire sous forme de symboles contenant les noms d'entités.

  • Les formes syntaxiques de select et update sont analysées dans leurs formes fonctionnelles équivalentes par le q interprète, il n'y a donc pas de différence de performance entre les deux formulaires.

Sélection fonctionnelle

Le bloc de code suivant montre comment utiliser functional select -

q)t:([]n:`ibm`msft`samsung`apple;p:40 38 45 54)

q)t

    n       p
-------------------
   ibm     40
   msft    38
 samsung   45
  apple    54

q)select m:max p,s:sum p by name:n from t where p>36, n in `ibm`msft`apple

  name |   m   s
------ | ---------
 apple |  54  54
 ibm   |  40  40
 msft  |  38  38

Exemple 1

Commençons par le cas le plus simple, la version fonctionnelle de “select from t” ressemblera à -

q)?[t;();0b;()]     / select from t

    n      p
-----------------
   ibm    40
   msft   38
 samsung  45
  apple   54

Exemple 2

Dans l'exemple suivant, nous utilisons la fonction enlist pour créer des singletons afin de garantir que les entités appropriées sont des listes.

q)wherecon: enlist (>;`p;40)

q)?[`t;wherecon;0b;()] / select from t where p > 40

    n      p
----------------
 samsung  45
  apple   54

Exemple 3

q)groupby: enlist[`p] ! enlist `p

q)selcols: enlist [`n]!enlist `n

q)?[ `t;(); groupby;selcols]        / select n by p from t

   p  |    n
----- | -------
  38  |  msft
  40  |  ibm
  45  | samsung
  54  | apple

Exécutif fonctionnel

La forme fonctionnelle d'exec est une forme simplifiée de select.

q)?[t;();();`n]                / exec n from t (functional form of exec)
`ibm`msft`samsung`apple

q)?[t;();`n;`p]                / exec p by n from t (functional exec)

apple   | 54
ibm     | 40
msft    | 38
samsung | 45

Mise à jour fonctionnelle

La forme fonctionnelle de mise à jour est tout à fait analogue à celle de select. Dans l'exemple suivant, l'utilisation d'enlist consiste à créer des singletons, pour garantir que les entités d'entrée sont des listes.

q)c:enlist (>;`p;0)

q)b: (enlist `n)!enlist `n

q)a: (enlist `p) ! enlist (max;`p)

q)![t;c;b;a]

   n      p
-------------
  ibm    40
  msft   38
 samsung 45
 apple   54

Suppression fonctionnelle

La suppression fonctionnelle est une forme simplifiée de mise à jour fonctionnelle. Sa syntaxe est la suivante -

![t;c;0b;a]        / t is a table, c is a list of where constraints, a is a
                   / list of column names

Prenons maintenant un exemple pour montrer comment fonctionne la suppression fonctionnelle -

q)![t; enlist (=;`p; 40); 0b;`symbol$()]
                                          / delete from t where p = 40
   n       p
---------------
  msft    38
 samsung  45
  apple   54