Skip to content

Latest commit

 

History

History

analytics

Folders and files

NameName
Last commit message
Last commit date

parent directory

..
examples
examples
 
 
src
src
 
 
test-utils
test-utils
 
 
test
test
 
 
.gitignore
.gitignore
 
 
.local.vimrc
.local.vimrc
 
 
.npmignore
.npmignore
 
 
CHANGELOG.md
CHANGELOG.md
 
 
README.md
README.md
 
 
package.json
package.json
 
 

README.md

analytics

Présentation

Ce plugin est propose une série d'instructions pour croiser, compter, trier, agréger des flux d’objets Javascript

installation

npm install @ezs/analytics

usage

Table of Contents

aggregate

Aggregate by id and count

[{
         { id: 'x', value: 2 },
         { id: 't', value: 2 },
         { id: 'x', value: 3 },
         { id: 'x', value: 5 },
}]

Script:

[use]
plugin = analytics

[aggregate]
path = id

Output:

[
         { id: 'x', value: [ 2, 3, 5] },
         { id: 't', value: [ 2 ]  },
]

Parameters

  • path String path to use for id (optional, default id)
  • value String path to use for value (if not found 1 is the default value) (optional, default value)

Returns Object

count

Take Object and throw special Object like {id, value} if key(s) was found id is the key, value is equal to 1 (if found)

[
 {
      "a": "nancy",
      "b": "lucy",
      "c": "geny",
  },
  {
      "a": "lorem",
      "b": "loret",
  },
  {
      "a": "fred",
  }
]

Script:

[use]
plugin = analytics

[count]
path = a
path = b
path = c

[aggregate]
[summing]

Output:

[{
   "id": "a",
   "value": 3
},
{
   "id": "b",
   "value": 2
},
{
   "id": "c",
   "value": 1
}]

Parameters

Returns Object

distance

To compare 2 fields with 2 id and compute a distance

  • for arrays, the distance is calculated according to the number of element in common
[{
           {
              id_of_a: 1,
              id_of_b: 2,
              a: ['x', 'y'],
              b: ['x', 'z'],
          },
          {
              id_of_a: 1,
              id_of_b: 3,
              a: ['x', 'y'],
              b: ['y', 'z'],
          },
          {
              id_of_a: 1,
              id_of_b: 4,
              a: ['x', 'y'],
              b: ['z'],
          },
          {
              id_of_a: 1,
              id_of_b: 5,
              a: ['x', 'y'],
              b: ['x', 'y', 'z'],
          },
          {
              id_of_a: 1,
              id_of_b: 6,
              a: ['x', 'y'],
              b: ['x', 'y'],
          },
}]

Script:

[use]
plugin = analytics

[distance]
id = id_of_a
id = id_of_b
value = a
value = b

Output:

[
    { id: [ 1, 2 ], value: 0.5 },
    { id: [ 1, 3 ], value: 0.5 },
    { id: [ 1, 4 ], value: 0 },
    { id: [ 1, 5 ], value: 0.8 },
    { id: [ 1, 6 ], value: 1 }
  ]

]

Parameters

  • path String path (optional, default value)

Returns Object

distinct

Take Object object getting some fields with json path, and do ...

[{
          { a: 'x', b: 'z' },
          { a: 't', b: 'z' },
          { a: 't', b: 'z' },
          { a: 'x', b: 'z' },
          { a: 'x', b: 'z' },
}]

Script:

[use]
plugin = analytics

[distinct]
path = a

Output:

[
          { id: 'x', value: 1 },
          { id: 't', value: 1 },
          { id: 't', value: 1 },
          { id: 'x', value: 1 },
          { id: 'x', value: 1 },
]

Parameters

  • path String path (optional, default "id")

Returns Object

distribute

Take Object like { id, value } and throw a serie of number value

[
          { id: 2000, value: 1 },
          { id: 2001, value: 2 },
          { id: 2003, value: 3 },
          { id: 2005, value: 4 },
          { id: 2007, value: 5 },
          { id: 2009, value: 6 },
          { id: 2011, value: 7 },
          { id: 2013, value: 8 },
]

Script:

[use]
plugin = analytics

[distribute]

Output:

[
      { "id": 2000, "value": 1 },
     { "id": 2001, "value": 2 },
     { "id": 2002, "value": 0 },
     { "id": 2003, "value": 3 },
     { "id": 2004, "value": 0 },
     { "id": 2005, "value": 4 },
     { "id": 2006, "value": 0 },
     { "id": 2007, "value": 5 },
     { "id": 2008, "value": 0 },
     { "id": 2009, "value": 6 },
     { "id": 2010, "value": 0 },
     { "id": 2011, "value": 7 },
     { "id": 2012, "value": 0 },
     { "id": 2013, "value": 8 }
]

Parameters

  • id String path to use for id (optional, default "id")
  • value String path to use for value (optional, default "value")
  • step String step between each value (optional, default 1)
  • start Number first value to throw (optional, default minvalueinthestream)
  • size Number size of the distribution (optional, default (maxvalue-minvalue)inthestream)
  • default Number default value for missing object (optional, default 0)

Returns Object

drop

Take Object and throw the same object only if there the value of the select field is not equals than a value

[
  {
   "departure": "nancy",
   "arrival": "paris",
 },
 {
   "departure": "nancy",
   "arrival": "toul",
 },
 {
   "departure": "paris",
   "arrival": "londre",
 }
]

Script:

[use]
plugin = analytics

[drop]

Output:

[{
  "departure": "nancy",
  "arrival": "paris"
},
{
   "departure": "nancy",
  "arrival": "toul"
}]

Parameters

  • path String path of the field to compare (optional, default "value")
  • if Number value to compare (optional, default "")

Returns Object

exploding

Take Object and take values with [value] path (must be an array) and throw object of each value. The new object is build with [id] and eac value.

[
 { departure: ['tokyo', 'nancy'], arrival: 'toul' },
 { departure: ['paris', 'nancy'], arrival: 'toul' },
 { departure: ['london', 'berlin'], arrival: 'toul' },
}]

Script:

[use]
plugin = analytics

[exploding]

Output:

[
   { "id": "toul", "value": "tokyo" },
   { "id": "toul", "value": "nancy" },
   { "id": "toul", "value": "paris" },
   { "id": "toul", "value": "nancy" },
   { "id": "toul", "value": "london" },
   { "id": "toul", "value": "berlin" }
]

Parameters

  • id String path to use for id (optional, default "id")
  • value String path to use for value (optional, default "value")

Returns Object

filter

Take Object and throw the same object only if there the value of the select field is equals than a value

  • 

    • 



[
{ id: 2000, value: 1 },
{ id: 2001, value: 2 },
{ id: 2003, value: 3 },
{ id: 2005, value: 4 },
{ id: 2007, value: 5 },
{ id: 2003, value: 3 },
{ id: 2011, value: 7 },
{ id: 2013, value: 8 },
]



Script:

```ini
[use]
plugin = analytics

[filter]
path = id
if = 2003
if = 2013




Output:


 [
          { id: 2003, value: 3 },
          { id: 2003, value: 3 },
          { id: 2013, value: 8 },
 ]


Parameters


    

  • path String path of the field to compare (optional, default "value")
    • 

  • if Number value to compare (optional, default "")
    • 



Returns Object 


graph


Take Object and throw a new special object (id, value) for each combination of values


[
 { cities: ['berlin', 'nancy', 'toul'] },
 { cities: ['paris', 'nancy', 'toul']},
 { cities: ['paris', 'berlin', 'toul'] },
}]


Script:


[use]
plugin = analytics

[graph]
path = cities



Output:


[
  { "id": [ "berlin", "nancy" ], "value": 1 },
  { "id": [ "berlin", "toul" ], "value": 2 },
  { "id": [ "nancy", "toul" ], "value": 2 },
  { "id": [ "nancy", "paris" ], "value": 1 },
  { "id": [ "paris", "toul" ], "value": 2 },
  { "id": [ "berlin", "paris" ], "value": 1 }
]


Parameters


    

  • path String 
    • 

  • identifier String path to use to set value result field (if not set or not exists, 1 is use as a default value) (optional, default false)
    • 



Returns Object 


greater


Take Object and throw the same object only if the value of the selected
field is greater (or equal) than a value


[
          { id: 2000, value: 1 },
          { id: 2001, value: 2 },
          { id: 2003, value: 3 },
          { id: 2005, value: 4 },
          { id: 2007, value: 5 },
          { id: 2009, value: 6 },
          { id: 2011, value: 7 },
          { id: 2013, value: 8 },
]


Script:


[use]
plugin = analytics

[greater]
than = 3
strict = true



Output:


[
          { id: 2005, value: 4 },
          { id: 2007, value: 5 },
          { id: 2009, value: 6 },
          { id: 2011, value: 7 },
          { id: 2013, value: 8 },
]


Parameters


    

  • path String path of the field to compare (optional, default "value")
    • 

  • than Number value to compare (optional, default 0)
    • 

  • strict Boolean greater than but not equal (optional, default false)
    • 



Returns Object 


groupingByEquality


Take Object like { id, value } and reduce all values with the same id
in a single object


[
   { "id": "lorem", "value": 1 },
   { "id": "Lorem", "value": 1 },
   { "id": "loren", "value": 1 },
   { "id": "korem", "value": 1 },
   { "id": "olrem", "value": 1 },
   { "id": "toto", "value": 1 },
   { "id": "titi", "value": 1 },
   { "id": "lorem", "value": 1 }
]


Script:


[use]
plugin = analytics

[groupingByEquality]

[summing]



Output:


[
  { "id": [ "lorem" ], "value": 2 },
  { "id": [ "Lorem" ], "value": 1 },
  { "id": [ "loren" ], "value": 1 },
  { "id": [ "korem" ], "value": 1 },
  { "id": [ "olrem" ], "value": 1 },
  { "id": [ "toto" ], "value": 1 },
  { "id": [ "titi" ], "value": 1 }
]


Parameters


    

  • id String path to use for id (optional, default id)
    • 

  • value String path to use for value (optional, default value)
    • 



Returns Object 


groupingByHamming


Take Object like { id, value } and reduce all value with id which
have the same Hamming distance in a single object


    

  • 

    

    • 



[
{ "id": "lorem", "value": 1 },
{ "id": "Lorem", "value": 1 },
{ "id": "loren", "value": 1 },
{ "id": "korem", "value": 1 },
{ "id": "olrem", "value": 1 },
{ "id": "toto", "value": 1 },
{ "id": "titi", "value": 1 },
{ "id": "lorem", "value": 1 }
]



Script:

```ini
[use]
plugin = analytics

[groupingByHamming]
distance = 1

[summing]




Output:


[
   { "id": [ "lorem", "Lorem", "loren", "korem" ], "value": 5 },
   { "id": [ "olrem" ], "value": 1 },
   { "id": [ "toto", "titi" ], "value": 2 }
]


Parameters


    

  • id String path to use for id (optional, default "id")
    • 

  • value String path to use for value (optional, default "value")
    • 



Returns Object 


groupingByLevenshtein


Take Object like { id, value } and reduce all values with
id which have the same Levenshtein distance in a single object


[
   { "id": "lorem", "value": 1 },
   { "id": "Lorem", "value": 1 },
   { "id": "loren", "value": 1 },
   { "id": "korem", "value": 1 },
   { "id": "olrem", "value": 1 },
   { "id": "toto", "value": 1 },
   { "id": "titi", "value": 1 },
   { "id": "lorem", "value": 1 }
]


Script:


[use]
plugin = analytics

[groupingByLevenshtein]
distance = 2

[summing]



Output:


[
   { "id": [ "lorem", "Lorem", "loren", "korem", "olrem" ], "value": 6 },
   { "id": [ "toto", "titi" ], "value": 2 }
]


Parameters


    

  • id String path to use for id (optional, default id)
    • 

  • value String path to use for value (optional, default value)
    • 

  • distance Number minimal levenshtein distance to have a same id (optional, default 1)
    • 



Returns Object 


groupingByModulo


Take Object like { id, value } and reduce all values with the same
modulo computation in a ansingle object


[{
}]


Script:


[use]
plugin = analytics

[groupingByModulo]



Output:


[
]


Parameters


    

  • id String path to use for id (optional, default id)
    • 

  • value String path to use for value (optional, default value)
    • 



Returns Object 


keys


Take Object and throws all its keys


[
 { city: 'tokyo', year: 2000, count: 1 },
 { city: 'paris', year: 2001, count: 2 },
 { city: 'london', year: 2003, count: 3 },
 { city: 'nancy', year: 2005, count: 4 },
 { city: 'berlin', year: 2007, count: 5 },
 { city: 'madrid', year: 2009, count: 6 },
 { city: 'stockholm', year: 2011, count: 7 },
 { city: 'bruxelles', year: 2013, count: 8 },
]


Script:


[use]
plugin = analytics

[keys]
[aggregate]
[summing]



Output:


[
{
   "id": "city",
   "value": 8
},
{
  "id": "year",
  "value": 8
},
{
   "id": "count",
   "value": 8
}⏎
]


Parameters



Returns Object 


less


Take Object and throw the same object only if the value of the selected
field is less (or equal) than a value


[{
          { id: 2000, value: 1 },
          { id: 2001, value: 2 },
          { id: 2003, value: 3 },
          { id: 2005, value: 4 },
          { id: 2007, value: 5 },
          { id: 2009, value: 6 },
          { id: 2011, value: 7 },
          { id: 2013, value: 8 },
}]


Script:


[use]
plugin = analytics

[less]
path = value
than = 4



Output:


[{
   "id": 2000,
   "value": 1
},
{
   "id": 2001,
  "value": 2
},
{
   "id": 2003,
   "value": 3
},
{
   "id": 2005,
   "value": 4
}]


Parameters


    

  • path String path of the field to compare (optional, default value)
    • 

  • than Number value to compare (optional, default 0)
    • 

  • strict Boolean less than but not equal (optional, default false)
    • 



Returns Object 


maximizing


Take special Object like {id, value} and replace value with the max of values


[
  { id: 'toul', value: [1, 2, 3] },
  { id: 'nancy', value: [2, 3, 4] },
  { id: 'neufchateau', value: [3, 4, 5] },
]


Script:


[use]
plugin = analytics

[maximizing]



Output:


[
   { "id": "toul", "value": 3 },
   { "id": "nancy", "value": 4 },
   { "id": "neufchateau", "value": 5 }
]


Parameters


    

  • id String path to use for id (optional, default id)
    • 

  • value String path to use for value (optional, default value)
    • 



Returns Object 


merging


Take special Object like {id, value} and replace value with the merge of values


[{
}]


Script:


[use]
plugin = analytics

[merging]



Output:


[
]


Parameters


    

  • id String path to use for id (optional, default id)
    • 

  • value String path to use for value (optional, default value)
    • 



Returns Object 


minimizing


Take special Object like {id, value} and replace value with the min of
values


[{
}]


Script:


[use]
plugin = analytics

[drop]



Output:


[
]


Parameters


    

  • id String path to use for id (optional, default id)
    • 

  • value String path to use for value (optional, default value)
    • 



Returns Object 


multiply


Take Object and throw the same object only if there the value of the select field is equals than a value
Input file:


[{
   a: 1,
   b: 2,
}]


Script:


[use]
plugin = analytics

[multiply]
path = factor
value = X
value = Y
value = Z



Output:


[{
   a: 1,
   b: 2,
   factor: X
},
{
   a: 1,
   b: 2,
   factor: Y
},
{
   a: 1,
   b: 2,
   factor: Z
},
]


Parameters


    

  • path String path of the field to add (optional, default "factor")
    • 

  • value String value(s) to set factor field (optional, default "")
    • 



Returns Object 


output


Create an output string containing all incoming elements in a data array.
with given meta extracted into an object called meta.


Créer une sortie en chain de caratere avec les element entrent mise dans un tableau nommé data
eyent les donnée meta extrais et mises dans un objet appelé meta.


Script / Scénario


ini


; Import analytics plugin required to use "output"
; Importation du plugin analytique nécessaire pour utiliser "output"
[use]
plugin = analytics

; Using "output" with 'indent' as true and 'meta' as total
; Utilisation de "output" avec 'indent' à vrai et total comme paramètres de 'meta'
[output]
indent = true
meta = total



Input / Entrée


 [
     { "_id": 1, "value": 2, "total": 2 },
     { "_id": 2, "value": 4, "total": 2 }
 ]


Output / Sortie


!!! Attention: This is an output function that can only be used at the end of an EZS script. !!!
!!! The output is a string and can't be used with other EZS functions.                       !!!


!!! Attention : Ceci est une fonction de sortie, Elle peut uniquement etre utilisé à la fin d'un script ezs !!!
!!! Cette sortie est une chaine de carater et ne peut pas etre utilisé avec d'autre fonction ezs            !!!


 {
     "data": [
         { "_id": 1, "value": 2 },
         { "_id": 2, "value": 4 }
     ],
     "meta": {
         "total": 2
     }
 }


Parameters


    

  • indent Boolean 
    • indent the output json
    

    • indenté le json de sortie
     (optional, default `false`)

    • 

  • meta String? 
    • element from the input to put it in the meta object
    

    • élément a extraire de l'entrée et a mettre dans l'objet `meta`
    

    • 



Returns String 


pair


Create a pair with 'id' containing a pair of the given 'path's and 'value' set to 1.


Créer un couple 'id' contenent un couple des 'path's donnée et 'value' mise à 1.


Script / Scénario


; Import analytics plugin required to use "pair"
; Importation du plugin analytique nécessaire pour utiliser "pair"
[use]
plugin = analytics

; Using "pair" with 'departure' and 'arrival' as paths setttings
; Utilisation de "pair" avec 'departure' et 'arrival' comme paramètres de paths
[pair]
path = departure
path = arrival



Input / Entrée


 [
     { "departure": ["tokyo", "nancy"], "arrival": "toul" },
     { "departure": ["paris", "nancy"], "arrival": "toul" },
     { "departure": ["london", "berlin"], "arrival": "toul" }
 ]


Output / Sortie


 [
     { "id": ["tokyo", "toul"], "value": 1 },
     { "id": ["nancy", "toul"], "value": 1 },
     { "id": ["paris", "toul"], "value": 1 },
     { "id": ["nancy", "toul"], "value": 1 },
     { "id": ["london", "toul"], "value": 1 },
     { "id": ["berlin", "toul"], "value": 1 }
 ]


Parameters


    

  • identifier String path to use to set value result field (if not set or not exists, 1 is use as a default value) (optional, default false)
    • 

  • null String 
    • path of the element who will be use to create the pair
    

    • chemin de l'élément qui vas etre utilisé pour créer le couple
    

    • 



Returns {id: Array<String>, value: 1} 


pluck


Extract the value of a given path and create a pair with the path as the id
and path value as the value.


Extrais la valeur d'un path donnée et créer un couple avec pour identifient le path
et comme value la valeur du path.


Example / Exemple


Script / Scénario


; Import analytics plugin required to use "pluck"
; Importation du plugin analytique nécessaire pour utiliser "pluck"
[use]
plugin = analytics

; Using "pluck" with 'year' as path setttings instead of 'id' how is the default value
; Utilisation de "pluck" avec 'year' comme paramètres de path au lieux de la valeur par defaut qui et 'id'
[pluck]
path = year



Input / Entrée


 [
     { "city": "tokyo", "year": 2000, "count": 1 },
     { "city": "paris", "year": 2001, "count": 2 },
     { "city": "london", "year": 2003, "count": 3 },
     { "city": "nancy", "year": 2005, "count": 4 },
     { "city": "berlin", "year": 2007, "count": 5 },
     { "city": "madrid", "year": 2009, "count": 6 },
     { "city": "stockholm", "year": 2011, "count": 7 },
     { "city": "bruxelles", "year": 2013, "count": 8 }
 ]


Output / Sortie


 [
     { "id": "year", "value": 2000 },
     { "id": "year", "value": 2001 },
     { "id": "year", "value": 2003 },
     { "id": "year", "value": 2005 },
     { "id": "year", "value": 2007 },
     { "id": "year", "value": 2009 },
     { "id": "year", "value": 2011 },
     { "id": "year", "value": 2013 }
 ]


Parameters


    

  • path String 
    • path of the element who need to be extrated
    

    • chemin de l'élément qui doit être extrais
     (optional, default `id`)

    • 



Returns {id: String, value: Object} 


reducing


Merges the id, value pairs into a new pair, associating the identifier with the values.


Fusionne les couple id, value, en un nouveau couple associent l'identifient au valeurs.


Example / Exemple


Script / Scénario


; Import analytics plugin required to use "reducing"
; Importation du plugin analytique nécessaire pour utiliser "reducing"
[use]
plugin = analytics

; Using "reducing" with default settings
; Utilisation de "reducing" avec les paramètres par défaut
[reducing]
; id = id
; value = value



Input / Entrée


 [
     { "id": "x", "value": 2 },
     { "id": "t", "value": 2 },
     { "id": "x", "value": 3 },
     { "id": "x", "value": 5 }
 ]


Output / Sortie


 [
     { "id": "x", "value": [2, 3, 5] },
     { "id": "t", "value": [2] }
 ]


Parameters


    

  • id String 
    • path of the element who will be use as the key
    

    • chemin de l'élément qui vas être utilisé comme clé
     (optional, default `id`)

    • 

  • value String 
    • path of the element who will be merge into an array
    

    • chemin de l'élément qui vas être fussioné en un tableau
     (optional, default `value`)

    • 



Returns {id: String, value: Array<Object>} 


segment


Returns an object containing a segmentation of the input.


    

  • [a,b,c] will be returned as [a,b], [b,c]
    • 



Renvoie un objet contenant une segmentation de l'entrée.


    

  • [a,b,c] sera retourné sous la forme [a,b], [b,c]
    • 



Example / Exemple


Script / Scénario


; Import analytics plugin required to use "segment"
; Importation du plugin analytique nécessaire pour utiliser "segment"
[use]
plugin = analytics

; Using "segment" with default settings
; Utilisation de "segment" avec les paramètres par défaut
[segment]
; aggregate = true
; identifier = false
; path = value



Input / Entrée


 [
     {
         "id": "doc#1",
         "value": [
             1,
             2,
             3,
             4
         ]
     },
     {
         "id": "doc#2",
         "value": [
             4,
             5,
             6
         ]
     },
     {
         "id": "doc#3",
         "value": [
             6,
             7
         ]
     },
     {
         "id": "doc#4",
         "value": [
             1,
             2,
             3,
             4,
             5,
             6,
             7
         ]
     }
 ]


Output / Sortie


 [
     { "id": [ 1, 2 ], "value": 1 },
     { "id": [ 2, 3 ], "value": 1 },
     { "id": [ 3, 4 ], "value": 1 },
     { "id": [ 4, 5 ], "value": 1 },
     { "id": [ 5, 6 ], "value": 1 },
     { "id": [ 6, 7 ], "value": 1 },
     { "id": [ 1, 2 ], "value": 1 },
     { "id": [ 2, 3 ], "value": 1 },
     { "id": [ 3, 4 ], "value": 1 },
     { "id": [ 4, 5 ], "value": 1 },
     { "id": [ 5, 6 ], "value": 1 },
     { "id": [ 6, 7 ], "value": 1 }
 ]


Parameters


    

  • path String 
    • path of the element who need to be segmented
    

    • chemin de l'élément qui doit être segmentés
     (optional, default `value`)

    • 

  • aggregate Boolean aggregate all values for all paths (or not)
    • aggregate all segmented value in one element (work if you have multiple path)
    

    • agréger toutes les valeurs segmentées en un seul élément (fonctionne si vous avez plusieurs chemins)
     (optional, default `true`)

    • 

  • identifier String 
    • path of the element who will be put in value field (if not set, fallback to 1)
    

    • chemin de l'élément qui sera mis dans le champ valeur (si non défini, fallback à `1`)
     (optional, default `false`)

    • 



Returns {id: Array<Number>, value: Object} 


slice


Returns a copy of a section of a stream.


Renvoie une copie d'une section d'un flux.


Example / Exemple


Script / Scénario


; Import analytics plugin required to use "slice"
; Importation du plugin analytique nécessaire pour utiliser "slice"
[use]
plugin = analytics

; Using "slice" with default settings
; Utilisation de "slice" avec les paramètres par défaut
[slice]
; start = 1
; size = 10



Input / Entrée


 [
     { "id": 2023, "value": 12 },
     { "id": 2021, "value": 11 },
     { "id": 2019, "value": 10 },
     { "id": 2017, "value": 9 },
     { "id": 2013, "value": 8 },
     { "id": 2011, "value": 7 },
     { "id": 2009, "value": 6 },
     { "id": 2007, "value": 5 },
     { "id": 2005, "value": 4 },
     { "id": 2003, "value": 3 },
     { "id": 2001, "value": 2 },
     { "id": 2000, "value": 1 }
 ]


Output / Sortie


 [
     { "id": 2023, "value": 12 },
     { "id": 2021, "value": 11 },
     { "id": 2019, "value": 10 },
     { "id": 2017, "value": 9 },
     { "id": 2013, "value": 8 },
     { "id": 2011, "value": 7 },
     { "id": 2009, "value": 6 },
     { "id": 2007, "value": 5 },
     { "id": 2005, "value": 4 },
     { "id": 2003, "value": 3 }
 ]


Parameters


    

  • start Number 
    • the beginning index of the specified portion of the stream
    

    • l'indice de début de la partie spécifiée du flux
     (optional, default `1`)

    • 

  • size Number 
    • the size of the specified portion of the stream
    

    • la taille de début de la partie spécifiée du flux
     (optional, default `10`)

    • 



Returns Object 


sort


Sort incomming objects based on the value of the given path.


Trie les objets entrants en fonction de la valeur du champ donné par path.


Example / Exemple


Script / Scénario


; Import analytics plugin required to use "sort"
; Importation du plugin analytique nécessaire pour utiliser "sort"
[use]
plugin = analytics

; Using "sort" with default settings
; Utilisation de "sort" avec les paramètres par défaut
[sort]
; path = id
; reverse = false



Input / Entrée


 [
     { "id": 2013, "value": 8 },
     { "id": 2011, "value": 7 },
     { "id": 2009, "value": 6 },
     { "id": 2007, "value": 5 },
     { "id": 2005, "value": 4 },
     { "id": 2003, "value": 3 },
     { "id": 2001, "value": 2 },
     { "id": 2000, "value": 1 }
 ]


Output / Sortie


 [
     { "id": 2000, "value": 1 },
     { "id": 2001, "value": 2 },
     { "id": 2003, "value": 3 },
     { "id": 2005, "value": 4 },
     { "id": 2007, "value": 5 },
     { "id": 2009, "value": 6 },
     { "id": 2011, "value": 7 },
     { "id": 2013, "value": 8 }
 ]


Parameters


    

  • path String 
    • path of the element used to as reference for the sort
    

    • chemin de l'élément utilisé comme référence pour le tri
     (optional, default `id`)

    • 

  • reverse boolean 
    • sort in ascending or descending order
    

    • trier par ordre croissant ou décroissant
     (optional, default `false`)

    • 



Returns Object 


statistics


Analyse and create statistics from given fields.


Analyse et crée des statistiques à partir des champs donnés.


Example / Exemple


Script / Scénario


; Import analytics plugin required to use "statistics"
; Importation du plugin analytique nécessaire pour utiliser "statistics"
[use]
plugin = analytics

; Using "statistics" with default settings
; Utilisation de "statistics" avec les paramètres par défaut
[statistics]
; path = value
; target = _statistics



Input / Entrée


 [
     { "value": 1 },
     { "value": 1 },
     { "value": 2 },
     { "value": 3 },
     { "value": 3 },
     { "value": 3 }
 ]


Output / Sortie


 [
     {
         "value": 1,
         "_statistics": {
             "value": {
                 "sample": 2,
                 "frequency": 1,
                 "percentage": 25,
                 "sum": 4,
                 "count": 3,
                 "min": 1,
                 "max": 2,
                 "mean": 1.3333333333333333,
                 "range": 1,
                 "midrange": 0.5,
                 "variance": 0.2222222222222222,
                 "deviation": 0.4714045207910317,
                 "population": 2
             }
         }
     },
     {
         "value": 1,
         "_statistics": {
             "value": {
                 "sample": 2,
                 "frequency": 1,
                 "percentage": 25,
                 "sum": 4,
                 "count": 3,
                 "min": 1,
                 "max": 2,
                 "mean": 1.3333333333333333,
                 "range": 1,
                 "midrange": 0.5,
                 "variance": 0.2222222222222222,
                 "deviation": 0.4714045207910317,
                 "population": 2
             }
         }
     },
     {
         "value": 2,
         "_statistics": {
             "value": {
                 "sample": 1,
                 "frequency": 0.5,
                 "percentage": 50,
                 "sum": 4,
                 "count": 3,
                 "min": 1,
                 "max": 2,
                 "mean": 1.3333333333333333,
                 "range": 1,
                 "midrange": 0.5,
                 "variance": 0.2222222222222222,
                 "deviation": 0.4714045207910317,
                 "population": 2
             }
         }
     }
 ]


Parameters


    

  • path String 
    • path of the element used to create the statistics
    

    • chemin de l'élément utilisé pour créer les statistiques
     (optional, default `value`)

    • 

  • target String 
    • path of the statistics in the returned object
    

    • chemin des stastistiques dans l'objet retourné
     (optional, default `_statistics`)

    • 



Returns Object 


summing


Create an id, value pair from two given paths and apply a sum to the value.


Créer un couple id, value à partir de chemins et applique une somme sur value.


Example / Exemple


Script / Scénario


; Import analytics plugin required to use "summing"
; Importation du plugin analytique nécessaire pour utiliser "summing"
[use]
plugin = analytics

; Using "summing" with default settings
; Utilisation de "summing" avec les paramètres par défaut
[summing]
; id = id
; value = value



Input / Entrée


 [
     {
         "id": 1,
         "value": [1, 1, 1],
         "hello": "world"
     },
     {
         "id": 2,
         "value": [2, 2, 2],
         "hello": "world"
     }
 ]


Output / Sortie


[
    {
        "id": 1,
        "value": 3
    },
    {
        "id": 2,
        "value": 6
    }
]


Parameters


    

  • id String 
    • path of the element used to create the new identifier
    

    • chemin de l'élément utilisé pour créer le nouvel identifiant
     (optional, default `id`)

    • 

  • value String 
    • path of the element to be summed
    

    • chemin de l'élément qui doit être sommé
     (optional, default `value`)

    • 



Returns {id: String, value: Object} 


tune


Create and replace the id with a unified id that can be used with sort.


Créer et remplacer l'identifiant par un identifiant unifié qui peut être utilisé avec sort.


Example / Exemple


Script / Scénario


; Import analytics plugin required to use "tune"
; Importation du plugin analytique nécessaire pour utiliser "tune"
[use]
plugin = analytics

; Using "tune" with default settings
; Utilisation de "tune" avec les paramètres par défaut
[tune]
; path = id
; method = natural



Input / Entrée


 [
     {
         "id": 1,
         "value": 1
     },
     {
         "id": 2,
         "value": 2
     }
 ]


Output / Sortie


 [
     {
         "id": "0000000000000000001.00000000000000000000",
         "value": {
             "id": 1,
             "value": 1,
             "label": "static value"
         }
     },
     {
         "id": "0000000000000000002.00000000000000000000",
         "value": {
             "id": 2,
             "value": 2,
             "label": "static value"
         }
     }
 ]


Parameters


    

  • path String 
    • path of the element used to create the unified identifier
    

    • chemin de l'élément utilisé pour créer l'identifiant unifié
     (optional, default `id`)

    • 

  • method ("natural" | "levenshtein" | "numerical") 
    • method used to create the unified identifier
    
 
      • natural - Create a normalised identifier that is set to a fixed length
    
 
      • levenshtein - Create an identifier based on the Levenshtein algorithm
    
 
      • numerical - Create an identifier based on a numeric value
    • méthode utilisée pour créer l'identifiant unifié
    
 
      • natural - Crée un identifiant normalisé de longueur fixe
    
 
      • levenshtein - Crée un identifiant basé sur l'algorithme de Levenshtein
    
 
      • numerical - Crée un identifiant basé sur une valeur numérique
     (optional, default `natural`)

    • 



Returns {id: String, value: Object} 


value


Create a new object from the value of the given path.


Créer un nouvel objet à partir du chemin donné dans path.


Example / Exemple


Script / Scénario


; Import analytics plugin required to use "value"
; Importation du plugin analytique nécessaire pour utiliser "value"
[use]
plugin = analytics

; Using "value" with default settings
; Utilisation de "tune" avec les paramètres par défaut
[value]
; path = value



Input / Entrée


Dataset 1 / Jeu de données 1


 [
     { "id": 2000, "value": 1 },
     { "id": 2001, "value": 2 },
     { "id": 2003, "value": 3 },
     { "id": 2005, "value": 4 },
     { "id": 2007, "value": 5 },
     { "id": 2009, "value": 6 },
     { "id": 2011, "value": 7 },
     { "id": 2013, "value": 8 }
 ]


Dataset 2 / Jeu de données 2


 [
     {
         "id": 1,
         "value": {
             "hello": "world"
         }
     },
     {
         "id": 2,
         "value": {
             "hello": "ezs"
         }
     },
     {
         "id": 3,
         "value": {
             "hello": "lodex"
         }
     }
 ]


Output / Sortie


Dataset 1 / Jeu de données 1


 [
     1,
     2,
     3,
     4,
     5,
     6,
     7,
     8
 ]


Dataset 2 / Jeu de données 2


 [
     {
         "hello": "world"
     },
     {
         "hello": "ezs"
     },
     {
         "hello": "lodex"
     }
 ]


Parameters


    

  • path String 
    • path of the element used to create the new object
    

    • chemin de l'élément utilisé pour créer le nouvel objet
     (optional, default `value`)

    • 



Returns Object