Data.table: Keyby / por não retornar grupos únicos com subconjuntos

Concordo que é um bug.

Para registro, o código recomendado neste caso é:

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

O que dá a resposta correta, já que esta versão ativará GForce e o bug não está presente nesse caso.

Claro que isso não ajuda se o seu código real não pode ser confundido assim.

Curiosamente, se passarmos as linhas do subconjunto diretamente, o código funcionará:

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

Vejo a seguinte diferença na saída de verbose :

Subconjunto otimizado com índice 'Grupo'

Isso me levou a instalar do CRAN; o código é executado sem erros em 1.10.4-3 .

Então eu acho que isso é algo do trabalho de

Também vejo o mesmo erro se tornarmos a junção explícita:

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

Mas a versão codificada está bem:

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

Obrigado @cathine por relatar e a @MichaelChirico por investigar.
A causa raiz é o comportamento com erros da versão de junção, conforme apontado por Michael:
dat[.('All'), on = 'Group', lapply(.SD, function(x) sum(x, na.rm = TRUE)), .SDcols= "count", keyby = ID]

Provavelmente serei resolvido quando o problema nº 2591 for resolvido.
Na nova otimização de subconjuntos, os subconjuntos são redirecionados para a parte de junção de data.table , portanto, este bug agora afeta subconjuntos, bem como junções. Vou tentar investigar o mais rápido possível se posso resolver o problema.
Até então, você pode recorrer a
dat[Group == "All"][ ,lapply(.SD, function(x) sum(x, na.rm = TRUE)), .SDcols= c("count"), keyby = ID, verbose = TRUE] por exemplo.
Desculpe pela inconveniência.

Obrigado @cathine! Confirmado que isso é apenas para desenvolvimento e pode ser aliviado com options(datatable.optimize=2) pois o problema parece estar no nível 3 de otimização. Estou me perguntando como isso escapou dos testes!
Exemplos ainda mais simples de outro contato que também relatou:

> 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
> 

Por que passou pelos testes? Porque só ocorre se a coluna de agrupamento for classificada (veja o código abaixo)! Não verifiquei especificamente o agrupamento em colunas classificadas.

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