Como excluir uma linha por referência em data.table?

Minha pergunta está relacionada à atribuição por referência versus cópia data.table. Quero saber se é possível excluir linhas por referência, semelhante a

DT[ , someCol := NULL]

Eu quero saber sobre

DT[someRow := NULL, ]

Eu acho que há uma boa razão para que essa função não exista, então talvez você possa apenas apontar uma boa alternativa para a abordagem de cópia usual, como abaixo. Em particular, indo com o meu favorito do exemplo (data.table),

DT = data.table(x = rep(c("a", "b", "c"), each = 3), y = c(1, 3, 6), v = 1:9)
#      x y v
# [1,] a 1 1
# [2,] a 3 2
# [3,] a 6 3
# [4,] b 1 4
# [5,] b 3 5
# [6,] b 6 6
# [7,] c 1 7
# [8,] c 3 8
# [9,] c 6 9

Digamos que eu queira excluir a primeira linha desta data.table. Eu sei que posso fazer isso:

DT <- DT[-1, ]

mas frequentemente podemos evitar isso, porque estamos copiando o objeto (e isso requer cerca de 3 * N de memória, se N object.size(DT), conforme indicado aqui . Agora eu encontrei set(DT, i, j, value). Eu sei como definir valores específicos (como aqui: definir tudo valores nas linhas 1 e 2 e nas colunas 2 e 3 a zero)

set(DT, 1:2, 2:3, 0) 
DT
#      x y v
# [1,] a 0 0
# [2,] a 0 0
# [3,] a 6 3
# [4,] b 1 4
# [5,] b 3 5
# [6,] b 6 6
# [7,] c 1 7
# [8,] c 3 8
# [9,] c 6 9

Mas como posso apagar as duas primeiras linhas, digamos? Fazendo

set(DT, 1:2, 1:3, NULL)

define o DT inteiro como NULL.

Meu conhecimento de SQL é muito limitado, então vocês me dizem: dado o data.table usa a tecnologia SQL, existe um equivalente ao comando SQL

DELETE FROM table_name
WHERE some_column=some_value

em data.table?

Boa pergunta. data.tableainda não pode excluir linhas por referência.

data.tablepode adicionar e excluir colunas por referência, pois aloca demais o vetor de ponteiros de coluna, como você sabe. O plano é fazer algo semelhante para linhas e permitir rápido inserte delete. Uma exclusão de linha seria usada memmoveem C para mover os itens (em cada coluna) após as linhas excluídas. A exclusão de uma linha no meio da tabela ainda seria bastante ineficiente em comparação com um banco de dados de armazenamento de linhas, como o SQL, que é mais adequado para inserção e exclusão rápidas de linhas onde quer que essas linhas estejam na tabela. Ainda assim, seria muito mais rápido do que copiar um novo objeto grande sem as linhas excluídas.

Por outro lado, como os vetores das colunas seriam superalocados, as linhas poderiam ser inseridas (e excluídas) no final , instantaneamente; por exemplo, uma série temporal crescente.

Está arquivado como um problema: exclua linhas por referência .

a abordagem adotada para tornar o uso da memória semelhante à exclusão no local é subconjunto de uma coluna por vez e exclusão. não tão rápido quanto uma solução C memmove adequada, mas o uso da memória é o que me interessa aqui. algo assim:

DT = data.table(col1 = 1:1e6)
cols = paste0('col', 2:100)
for (col in cols){ DT[, (col) := 1:1e6] }
keep.idxs = sample(1e6, 9e5, FALSE) # keep 90% of entries
DT.subset = data.table(col1 = DT[['col1']][keep.idxs]) # this is the subsetted table
for (col in cols){
  DT.subset[, (col) := DT[[col]][keep.idxs]]
  DT[, (col) := NULL] #delete
}

Aqui está uma função de trabalho baseada na resposta de @ vc273 e no feedback de @ Frank.

delete <- function(DT, del.idxs) {           # pls note 'del.idxs' vs. 'keep.idxs'
  keep.idxs <- setdiff(DT[, .I], del.idxs);  # select row indexes to keep
  cols = names(DT);
  DT.subset <- data.table(DT[[1]][keep.idxs]); # this is the subsetted table
  setnames(DT.subset, cols[1]);
  for (col in cols[2:length(cols)]) {
    DT.subset[, (col) := DT[[col]][keep.idxs]];
    DT[, (col) := NULL];  # delete
  }
   return(DT.subset);
}

E exemplo de seu uso:

dat <- delete(dat,del.idxs)   ## Pls note 'del.idxs' instead of 'keep.idxs'

Onde "dat" é uma tabela de dados. Remover 14k linhas de 1.4M linhas leva 0.25 segundos no meu laptop.

> dim(dat)
[1] 1419393      25
> system.time(dat <- delete(dat,del.idxs))
   user  system elapsed 
   0.23    0.02    0.25 
> dim(dat)
[1] 1404715      25
> 

PS. Como sou novo no SO, não pude adicionar comentários ao tópico do @ vc273 :-(

Em vez disso, ou tentando definir como NULL, tente definir para NA (correspondendo ao tipo de NA da primeira coluna)

set(DT,1:2, 1:3 ,NA_character_)

O tópico ainda é interessante para muitas pessoas (inclusive eu).

Que tal? Eu costumava assignsubstituir glovalenvo código descrito anteriormente. Seria melhor capturar o ambiente original, mas pelo menos globalenvnele é eficiente em memória e age como uma alteração por ref.

delete <- function(DT, del.idxs) 
{ 
  varname = deparse(substitute(DT))

  keep.idxs <- setdiff(DT[, .I], del.idxs)
  cols = names(DT);
  DT.subset <- data.table(DT[[1]][keep.idxs])
  setnames(DT.subset, cols[1])

  for (col in cols[2:length(cols)]) 
  {
    DT.subset[, (col) := DT[[col]][keep.idxs]]
    DT[, (col) := NULL];  # delete
  }

  assign(varname, DT.subset, envir = globalenv())
  return(invisible())
}

DT = data.table(x = rep(c("a", "b", "c"), each = 3), y = c(1, 3, 6), v = 1:9)
delete(DT, 3)

Aqui estão algumas estratégias que eu usei. Acredito que uma função .ROW possa estar chegando. Nenhuma dessas abordagens abaixo é rápida. Estas são algumas estratégias um pouco além dos subconjuntos ou da filtragem. Eu tentei pensar como dba apenas tentando limpar os dados. Como observado acima, você pode selecionar ou remover linhas em data.table:

data(iris)
iris <- data.table(iris)

iris[3] # Select row three

iris[-3] # Remove row three

You can also use .SD to select or remove rows:

iris[,.SD[3]] # Select row three

iris[,.SD[3:6],by=,.(Species)] # Select row 3 - 6 for each Species

iris[,.SD[-3]] # Remove row three

iris[,.SD[-3:-6],by=,.(Species)] # Remove row 3 - 6 for each Species

Nota: .SD cria um subconjunto dos dados originais e permite que você trabalhe bastante em j ou na tabela de dados subsequente. Consulte https://stackoverflow.com/a/47406952/305675 . Aqui eu encomendei minhas íris por Comprimento Sepal, pegue um Sepal.Length especificado, no mínimo, selecione os três primeiros (por Comprimento Sepal) de todas as Espécies e retorne todos os dados que os acompanham:

iris[order(-Sepal.Length)][Sepal.Length > 3,.SD[1:3],by=,.(Species)]

As abordagens acima de tudo reordenam uma tabela de dados sequencialmente ao remover linhas. Você pode transpor uma tabela de dados e remover ou substituir as linhas antigas que agora são colunas transpostas. Ao usar ': = NULL' para remover uma linha transposta, o nome da coluna subsequente também é removido:

m_iris <- data.table(t(iris))[,V3:=NULL] # V3 column removed

d_iris <- data.table(t(iris))[,V3:=V2] # V3 column replaced with V2

Quando você transpõe o data.frame de volta para uma data.table, convém renomear a partir da data.table original e restaurar os atributos da classe no caso de exclusão. A aplicação ": = NULL" a uma tabela de dados agora transposta cria todas as classes de caracteres.

m_iris <- data.table(t(d_iris));
setnames(d_iris,names(iris))

d_iris <- data.table(t(m_iris));
setnames(m_iris,names(iris))

Você pode apenas querer remover linhas duplicadas que você pode fazer com ou sem uma chave:

d_iris[,Key:=paste0(Sepal.Length,Sepal.Width,Petal.Length,Petal.Width,Species)]     

d_iris[!duplicated(Key),]

d_iris[!duplicated(paste0(Sepal.Length,Sepal.Width,Petal.Length,Petal.Width,Species)),]  

Também é possível adicionar um contador incremental com '.I'. Você pode procurar chaves ou campos duplicados e removê-los removendo o registro do contador. Isso é computacionalmente caro, mas tem algumas vantagens, pois você pode imprimir as linhas a serem removidas.

d_iris[,I:=.I,] # add a counter field

d_iris[,Key:=paste0(Sepal.Length,Sepal.Width,Petal.Length,Petal.Width,Species)]

for(i in d_iris[duplicated(Key),I]) {print(i)} # See lines with duplicated Key or Field

for(i in d_iris[duplicated(Key),I]) {d_iris <- d_iris[!I == i,]} # Remove lines with duplicated Key or any particular field.

Você também pode preencher uma linha com 0s ou NAs e, em seguida, usar uma consulta i para excluí-los:

 X 
   x v foo
1: c 8   4
2: b 7   2

X[1] <- c(0)

X
   x v foo
1: 0 0   0
2: b 7   2

X[2] <- c(NA)
X
    x  v foo
1:  0  0   0
2: NA NA  NA

X <- X[x != 0,]
X <- X[!is.na(x),]