Data.table: Keyby / en ne renvoyant pas de groupes uniques avec sous-ensemble

D'accord, c'est un bug.

Pour mémoire, le code recommandé dans ce cas est:

dat[Group == "All", lapply(.SD, sum, na.rm = TRUE), .SDcols= c("count"), keyby = ID]

Ce qui donne la bonne réponse puisque cette version activera GForce et le bogue n'est pas présent dans ce cas.

Bien sûr, cela ne sert à rien si votre code réel ne peut pas être modifié comme ça.

Fait intéressant, si nous transmettons directement les lignes du sous-ensemble, le code fonctionne:

dat[c(1, 3, 5, 7),
    lapply(.SD, function(x) sum(x, na.rm = TRUE)),
    .SDcols= "count", keyby = ID, verbose = TRUE]
# i clause present and columns used in by detected, only these subset: ID 
# Finding groups using forderv ... 0.000sec 
# Finding group sizes from the positions (can be avoided to save RAM) ... 0.000sec 
# lapply optimization changed j from 'lapply(.SD, function(x) sum(x, na.rm = TRUE))' to 'list(..FUN1(count))'
# GForce is on, left j unchanged
# Old mean optimization is on, left j unchanged.
# Making each group and running j (GForce FALSE) ... 
#   collecting discontiguous groups took 0.000s for 2 groups
#   eval(j) took 0.000s for 2 calls
# 0.000sec 
#    ID count
# 1:  1     4
# 2:  2    12

Je vois la différence suivante dans la sortie verbose :

Sous-ensemble optimisé avec l'index 'Groupe'

Cela m'a conduit à installer à partir de CRAN; le code s'exécute sans erreur sur 1.10.4-3 .

Donc je suppose que c'est quelque chose du travail de

Je vois également la même erreur si nous rendons la jointure explicite:

dat[.('All'), on = 'Group',
    lapply(.SD, function(x) sum(x, na.rm = TRUE)),
    .SDcols= "count", keyby = ID]
#    ID count
# 1:  1     4
# 2:  1    12

Mais la version à clé est bien:

setkey(dat, Group)
dat[.('All'), 
    lapply(.SD, function(x) sum(x, na.rm = TRUE)),
    .SDcols= "count", keyby = ID]#    ID count
# 1:  1     4
# 2:  2    12

Merci à @cathine pour le rapport et à @MichaelChirico pour l'enquête.
La cause première est le comportement bogué de la version join comme indiqué par Michael:
dat[.('All'), on = 'Group', lapply(.SD, function(x) sum(x, na.rm = TRUE)), .SDcols= "count", keyby = ID]

Sera probablement résolu lorsque ce problème # 2591 sera résolu.
Dans la nouvelle optimisation des sous-ensembles, les sous-ensembles sont redirigés vers la partie jointure de data.table , donc ce bogue affecte désormais les sous-ensembles ainsi que les jointures. J'essaierai d'enquêter dès que possible si je peux résoudre le problème.
Jusque-là, vous pouvez recourir à
dat[Group == "All"][ ,lapply(.SD, function(x) sum(x, na.rm = TRUE)), .SDcols= c("count"), keyby = ID, verbose = TRUE] par exemple.
Désolé pour le dérangement.

Merci @cathine! Confirmé, ceci est uniquement destiné aux développeurs et peut être résolu avec options(datatable.optimize=2) car le problème semble être dans l'optimisation de niveau 3. Je me demande comment cela a réussi à passer les tests!
Exemples encore plus simples d'un autre contact qui a également signalé:

> DT = data.table(
    id = c("a","a","a","b","b","c","c","d","d"),
    group = c(1,1,1,1,1,2,2,2,2),
    num = 1)
> DT[, uniqueN(id), by=group]          # ok 
   group    V1
   <num> <int>
1:     1     2
2:     2     2
> DT[num==1, uniqueN(id), by=group]    # group column wrong
   group    V1
   <num> <int>
1:     1     2
2:     1     2
> options(datatable.optimize=2)
> DT[num==1, uniqueN(id), by=group]    # ok
   group    V1
   <num> <int>
1:     1     2
2:     2     2
> options(datatable.optimize=3)        # not ok
> DT[num==1, uniqueN(id), by=group]
   group    V1
   <num> <int>
1:     1     2
2:     1     2
> DT[num==1, sum(num), by=group]       # ok
   group    V1
   <num> <num>
1:     1     7
2:     2     4
> DT[num==1, length(num), by=group]    # not ok
   group    V1
   <num> <int>
1:     1     7
2:     1     4
> options(datatable.optimize=2)        # ok
> DT[num==1, length(num), by=group]
   group    V1
   <num> <int>
1:     1     7
2:     2     4
> 

Pourquoi a-t-il échappé aux tests? Car cela ne se produit que si la colonne de regroupement est triée (voir code ci-dessous) ! Je n'ai pas vérifié spécifiquement le regroupement sur les colonnes triées.

library(data.table)
DT = data.table(
  id = c("a","a","a","b","b","c","c","d","d"),
  group = c(1,1,1,1,1,2,2,2,2),
  group2 = c(1,1,1,1,1,2,2,2,1),
  num = 1)
DT[, uniqueN(id), by=group]          # ok 
# group    V1
# <num> <int>
# 1:     1     2
# 2:     2     2
DT[num==1, uniqueN(id), by=group]    # group column wrong
# group    V1
# <num> <int>
# 1:     1     2
# 2:     1     2
DT[num==1, uniqueN(id), by=group2]    # ok with other group column that is not sorted
# group2 V1
# 1:      1  3
# 2:      2  2

setkey(DT, group2)
DT[num==1, uniqueN(id), by=group2]    # not ok anymore since the group column is sorted now
# group2 V1
# 1:      1  3
# 2:      1  2