new tests, slight change in behavior

Author: joshhwuu

R/data.table.R

@@ -1139,7 +1139,8 @@ replace_dot_alias = function(e) {
             }
           }
           names(jsub)=""
-          jsub[[1L]]=as.name("list")
+          # dont wrap the RHS in list if it is a singular NULL and if not creating a new column
+          if (length(jsub[-1L]) == 1L && as.character(jsub[-1L]) == 'NULL' && all(lhs %chin% names_x)) jsub[[1L]]=as.name("identity") else jsub[[1L]]=as.name("list")
         }
         av = all.vars(jsub,TRUE)
         if (!is.atomic(lhs)) stopf("LHS of := must be a symbol, or an atomic vector (column names or positions).")

inst/tests/tests.Rraw

@@ -18613,58 +18613,228 @@ test(2263.4, options=list(datatable.verbose=TRUE, datatable.optimize=Inf), dt[,
 test(2263.5, options=list(datatable.verbose=TRUE, datatable.optimize=Inf), dt[, .N, .(b,c)], data.table(b=dt$b, c=dt$c, N=1L), output="GForce optimized j to")
 test(2263.6, options=list(datatable.verbose=TRUE, datatable.optimize=Inf), names(attributes(dt[, .N, b]$b)), c("class", "att"), output="GForce optimized j to")
 
-# tests for replacing an element of a list column with NULL instead of deleting the column, #5558
+# tests for new consistent replacement of list columns with list(NULL), #5558
+# replacement of a list column with list(NULL) in a single-row data.table, using different assignment methods
 DT = data.table(L = list("A"), i = 1L)
+ans = data.table(L = list(NULL), i = 1L)
+# test using replacement with $ operator
 DT$L = list(NULL)
-# Test replacement of a list column with list(NULL) using $ to access the column
-test(2264.01, DT, data.table(L = list(NULL), i = 1L))
+test(2264.01, DT, ans)
 DT = data.table(L = list("A"), i = 1L)
-# Test same replacement but with LHS := RHS operator
-test(2264.02, DT[, L := list(NULL)], data.table(L = list(NULL), i = 1L))
+# standard form with := operator
+test(2264.02, copy(DT)[, L := list(NULL)], ans)
+# functional form with := operator
+test(2264.03, copy(DT)[, `:=`(L = list(NULL))], ans)
+# functional form with 'let' alias
+test(2264.04, copy(DT)[, let(L = list(NULL))], ans)
+# using set()
+test(2264.05, set(copy(DT), j = "L", value = list(NULL)), ans)
+# tests doing the same as above, but with multiple columns
+DT = data.table(L1 = list("A"), L2 = list("B"), i = 1L)
+ans = data.table(L1 = list(NULL), L2 = list(NULL), i = 1L)
+DT$L1 = list(NULL)
+DT$L2 = list(NULL)
+test(2264.06, DT, ans)
+DT = data.table(L1 = list("A"), L2 = list("B"), i = 1L)
+# standard form with := operator
+test(2264.07, copy(DT)[, c("L1", "L2") := list(list(NULL), list(NULL))], ans)
+# functional form with := operator
+test(2264.08, copy(DT)[, `:=`(L1 = list(NULL), L2 = list(NULL))], ans)
+# functional form with 'let' alias
+test(2264.09, copy(DT)[, let(L1 = list(NULL), L2 = list(NULL))], ans)
+# using set()
+test(2264.10, set(copy(DT), j = c("L1", "L2"), value = list(list(NULL), list(NULL))), ans)
+
+# replacement of a list column with list(NULL) in a multi-row data.table, using different assignment methods
+DT = data.table(L = list("A", "B"), i = 1L)
+ans = data.table(L = list(NULL, NULL), i = 1L)
+# test using replacement with $ operator
+DT$L = list(NULL)
+test(2264.11, DT, ans)
+DT = data.table(L = list("A", "B"), i = 1L)
+# standard form with := operator
+test(2264.12, copy(DT)[, L := list(NULL)], ans)
+# functional form with := operator
+test(2264.13, copy(DT)[, `:=`(L = list(NULL))], ans)
+# functional form with 'let' alias
+test(2264.14, copy(DT)[, let(L = list(NULL))], ans)
+# using set()
+test(2264.15, set(copy(DT), j = "L", value = list(NULL)), ans)
+# tests doing the same as above, but with multiple columns
+DT = data.table(L1 = list("A", "B"), L2 = list("B", "C"), i = 1L)
+ans = data.table(L1 = list(NULL, NULL), L2 = list(NULL, NULL), i = 1L)
+DT$L1 = list(NULL)
+DT$L2 = list(NULL)
+test(2264.16, DT, ans)
+DT = data.table(L1 = list("A", "B"), L2 = list("B", "C"), i = 1L)
+# standard form with := operator
+test(2264.17, copy(DT)[, c("L1", "L2"):= list(list(NULL), list(NULL))], ans)
+# functional form with := operator
+test(2264.18, copy(DT)[, `:=`(L1 = list(NULL), L2 = list(NULL))], ans)
+# functional form with 'let' alias
+test(2264.19, copy(DT)[, let(L1 = list(NULL), L2 = list(NULL))], ans)
+# using set()
+test(2264.20, set(copy(DT), j = c("L1", "L2"), value = list(list(NULL), list(NULL))), ans)
+
+# Adding an empty list column to a single-row data.table, using different assignment methods
 DT = data.table(L = list("A"), i = 1L)
-DT1 = data.table(L = list("A"), i = 1L)
-# Test that := operator and functional form `:=` have the same result
-test(2264.03, DT[, L := list(NULL)], DT1[, `:=`(L = list(NULL))])
+ans = data.table(L = list("A"), i = 1L, D = list(NULL))
+warn = "Tried to assign NULL to column 'D', but this column does not exist to remove"
+# try to add a new empty list by list(NULL) with := in standard form, warns and does not change
+test(2264.21, copy(DT)[, D := list(NULL)], DT, warning=warn)
+test(2264.22, set(copy(DT), j = "D", value = list(NULL)), DT, warning=warn)
+# add a new column by wrapping list(NULL), consistent with old behavior
+DT$D = list(list(NULL))
+test(2264.23, DT, ans)
 DT = data.table(L = list("A"), i = 1L)
-DT1 = data.table(L = list("A"), i = 1L)
-# Test that functional operator and let have the same result
-test(2264.04, DT[, `:=`(L = list(NULL))], DT1[, let(L = list(NULL))])
-# Similar tests below but DT list column has more than one entry
-DT = data.table(L = list("B", "C"), i = 1L)
-DT$L = list(NULL)
-test(2264.05, DT, data.table(L = list(NULL, NULL), i = 1L))
-DT = data.table(L = list("B", "C"), i = 1L)
-test(2264.06, DT[, L := list(NULL)], data.table(L = list(NULL, NULL), i = 1L))
-DT = data.table(L = list("B", "C"), i = 1L)
-DT1 = data.table(L = list("B", "C"), i = 1L)
-test(2264.07, DT[, L := list(NULL)], DT1[, `:=`(L = list(NULL))])
-DT = data.table(L = list("B", "C"), i = 1L)
-DT1 = data.table(L = list("B", "C"), i = 1L)
-test(2264.08, DT[, `:=`(L = list(NULL))], DT1[, let(L = list(NULL))])
-# Tests for add/remove columns
-DT = data.table(L = list("B"), i = 1L)
-# warns, does not add
-DT$new = list(NULL)
-test(2264.09, DT, data.table(L = list("B"), i = 1L))
-test(2264.10, copy(DT)[, D := list(NULL)], data.table(L = list("B"), i = 1L), warning="Tried to assign NULL to column 'D', but this column does not exist to remove")
-# works, adds in functional form
-test(2264.11, copy(DT)[, `:=`(D = list(NULL))], data.table(L = list("B"), i = 1L, D = list(NULL)))
-# remove list column, must use NULL instead of list(NULL)
-test(2264.12, copy(DT)[, L := NULL], data.table(i = 1L))
-# remove non-list column, same as old
-test(2264.13, copy(DT)[, i := NULL], data.table(L = list("B")))
-# Same tests, with multiple rows
-DT = data.table(L = list("B", "C"), i = 1L)
-test(2264.14, copy(DT)[, D := list(NULL)], data.table(L = list("B", "C"), i = 1L), warning="Tried to assign NULL to column 'D', but this column does not exist to remove")
-test(2264.15, copy(DT)[, `:=`(D = list(NULL))], data.table(L = list("B", "C"), i = 1L, D = list(NULL)))
-test(2264.16, copy(DT)[, L := NULL], data.table(i = c(1L, 1L)))
-test(2264.17, copy(DT)[, i := NULL], data.table(L = list("B", "C")))
-# test for deleting a list column and adding a new empty list column in the same query, same as before
-test(2264.18, copy(DT)[, c("L", "D") := list(NULL, list(NULL))], data.table(i = c(1L, 1L), D = list(NULL)))
-# test for deleting everything
-test(2264.19, copy(DT)[, c("L", "i") := NULL], data.table())
-# test for replacement of multiple empty list columns
-DT = data.table(L1 = list("B", "C"), L2 = list("C", "D"), i = 1L)
-test(2264.20, copy(DT)[, c("L1", "L2") := list(list(NULL), list(NULL))], data.table(L1 = list(NULL), L2 = list(NULL), i = c(1L, 1L)))
-# test for removal of multiple empty list columns
-test(2264.21, copy(DT)[, c("L1", "L2") := NULL], data.table(i = c(1L, 1L)))
+# test adding empty list column in standard form with := operator
+test(2264.24, copy(DT)[, D := .(list(NULL))], ans)
+# functional form with := operator
+test(2264.25, copy(DT)[, `:=`(D = list(NULL))], ans)
+# functional form with 'let' alias
+test(2264.26, copy(DT)[, let(D = list(NULL))], ans)
+# using set()
+test(2264.27, set(copy(DT), j = "D", value = list(list(NULL))), ans)
+# tests doing the same as above, but with multiple columns
+DT = data.table(L = list("A"), i = 1L)
+ans = data.table(L = list("A"), i = 1L, D = list(NULL), R = list(NULL))
+DT$D = list(list(NULL))
+DT$R = list(list(NULL))
+test(2264.28, DT, ans)
+DT = data.table(L = list("A"), i = 1L)
+# standard form with := operator
+test(2264.29, copy(DT)[, c("D", "R"):= .(list(NULL))], ans)
+# functional form with := operator
+test(2264.30, copy(DT)[, `:=`(D = list(NULL), R = list(NULL))], ans)
+# functional form with 'let' alias
+test(2264.31, copy(DT)[, let(D = list(NULL), R = list(NULL))], ans)
+# using set()
+test(2264.32, set(copy(DT), j = c("D", "R"), value = list(list(NULL))), ans)
+
+# Adding an empty list column to a multi-row data.table, using different assignment methods
+DT = data.table(L = list("A", "B"), i = 1L)
+ans = data.table(L = list("A", "B"), i = 1L, D = list(NULL, NULL))
+warn = "Tried to assign NULL to column 'D', but this column does not exist to remove"
+# try to add a new empty list by list(NULL) with := in standard form, warns and does not change
+test(2264.33, copy(DT)[, D := list(NULL)], DT, warning=warn)
+test(2264.34, set(copy(DT), j = "D", value = list(NULL)), DT, warning=warn)
+# add a new column by wrapping list(NULL), consistent with old behavior
+DT$D = list(list(NULL))
+test(2264.35, DT, ans)
+DT = data.table(L = list("A", "B"), i = 1L)
+# test adding empty list column in standard form with := operator
+test(2264.36, copy(DT)[, D := .(list(NULL))], ans)
+# functional form with := operator
+test(2264.37, copy(DT)[, `:=`(D = list(NULL))], ans)
+# functional form with 'let' alias
+test(2264.38, copy(DT)[, let(D = list(NULL))], ans)
+# using set()
+test(2264.39, set(copy(DT), j = "D", value = list(list(NULL))), ans)
+# tests doing the same as above, but with multiple columns
+DT = data.table(L = list("A", "B"), i = 1L)
+ans = data.table(L = list("A", "B"), i = 1L, D = list(NULL, NULL), R = list(NULL, NULL))
+DT$D = list(list(NULL))
+DT$R = list(list(NULL))
+test(2264.40, DT, ans)
+DT = data.table(L = list("A", "B"), i = 1L)
+# standard form with := operator
+test(2264.41, copy(DT)[, c("D", "R"):= .(list(NULL))], ans)
+# functional form with := operator
+test(2264.42, copy(DT)[, `:=`(D = list(NULL), R = list(NULL))], ans)
+# functional form with 'let' alias
+test(2264.43, copy(DT)[, let(D = list(NULL), R = list(NULL))], ans)
+# using set()
+test(2264.44, set(copy(DT), j = c("D", "R"), value = list(list(NULL))), ans)
+
+# Removal of a list column in a single-row data.table, using different assignment methods
+# NOTE: There is only one way to remove columns now, by assigning to NULL
+DT = data.table(L = list("A"), i = 1L)
+ans = data.table(i = 1L)
+# test removing a list column by assigning to NULL
+DT$L = NULL
+test(2264.45, DT, ans)
+DT = data.table(L = list("A"), i = 1L)
+# standard form with := operator
+test(2264.46, copy(DT)[, L := NULL], ans)
+# functional form with := operator
+test(2264.47, copy(DT)[, `:=`(L = NULL)], ans)
+# functional form with 'let' alias
+test(2264.48, copy(DT)[, let(L = NULL)], ans)
+# using set()
+test(2264.49, set(copy(DT), j = "L", value = NULL), ans)
+# test doing the same as above, but with multiple columns
+DT = data.table(L1 = list("A"), L2 = list("B"), i = 1L)
+# test removing two list columns by assigning to NULL
+DT$L1 = NULL
+DT$L2 = NULL
+test(2264.50, DT, ans)
+DT = data.table(L1 = list("A"), L2 = list("B"), i = 1L)
+# standard form with := operator
+test(2264.51, copy(DT)[, c("L1", "L2") := NULL], ans)
+# functional form with := operator
+test(2264.52, copy(DT)[, `:=`(L1 = NULL, L2 = NULL)], ans)
+# functional form with 'let' alias
+test(2264.53, copy(DT)[, let(L1 = NULL, L2 = NULL)], ans)
+# using set()
+test(2264.54, set(copy(DT), j = c("L1", "L2"), value = NULL), ans)
+
+# Removal of a list column in a multi-row data.table, using different assignment methods
+DT = data.table(L = list("A", "B"), i = 1L)
+ans = data.table(i = c(1L, 1L))
+# test removing a list column by assigning to NULL
+DT$L = NULL
+test(2264.55, DT, ans)
+DT = data.table(L = list("A", "B"), i = 1L)
+# standard form with := operator
+test(2264.56, copy(DT)[, L := NULL], ans)
+# functional form with := operator
+test(2264.57, copy(DT)[, `:=`(L = NULL)], ans)
+# functional form with 'let' alias
+test(2264.58, copy(DT)[, let(L = NULL)], ans)
+# using set()
+test(2264.59, set(copy(DT), j = "L", value = NULL), ans)
+# test doing the same as above, but with multiple columns
+DT = data.table(L1 = list("A", "B"), L2 = list("B", "C"), i = 1L)
+# test removing two list columns by assigning to NULL
+DT$L1 = NULL
+DT$L2 = NULL
+test(2264.60, DT, ans)
+DT = data.table(L1 = list("A", "B"), L2 = list("B", "C"), i = 1L)
+# standard form with := operator
+test(2264.61, copy(DT)[, c("L1", "L2") := NULL], ans)
+# functional form with := operator
+test(2264.62, copy(DT)[, `:=`(L1 = NULL, L2 = NULL)], ans)
+# functional form with 'let' alias
+test(2264.63, copy(DT)[, let(L1 = NULL, L2 = NULL)], ans)
+# using set()
+test(2264.64, set(copy(DT), j = c("L1", "L2"), value = NULL), ans)
+
+# Combining queries (add/remove/replace columns in the same query) for a single-row data.table
+DT = data.table(L = list("A"), i = 1L)
+# test for adding a new empty list column D and removing column L in the same query
+ans = data.table(i = 1L, D = list(NULL))
+test(2264.65, copy(DT)[, c("L", "D") := list(NULL, list(NULL))], ans)
+test(2264.66, copy(DT)[, `:=`(L = NULL, D = list(NULL))], ans)
+test(2264.67, copy(DT)[, let(L = NULL, D = list(NULL))], ans)
+test(2264.68, set(copy(DT), j = c("L", "D"), value = list(NULL, list(NULL))), ans)
+DT = data.table(L = list("A"), i = 1L)
+# test for adding a new empty list column D and replacing column L with empty list in the same query
+ans = data.table(L = list(NULL), i = 1L, D = list(NULL))
+test(2264.69, copy(DT)[, c("L", "D") := list(list(NULL), list(NULL))], ans)
+test(2264.70, copy(DT)[, `:=`(L = list(NULL), D = list(NULL))], ans)
+test(2264.71, copy(DT)[, let(L = list(NULL), D = list(NULL))], ans)
+test(2264.72, set(copy(DT), j = c("L", "D"), value = list(list(NULL), list(NULL))), ans)
+DT = data.table(L = list("A"), D = list("B"), i = 1L)
+# test for replacing column L with an empty list and removing list column D in the same query
+ans = data.table(L = list(NULL), i = 1L)
+test(2264.73, copy(DT)[, c("L", "D") := list(list(NULL), NULL)], ans)
+test(2264.74, copy(DT)[, `:=`(L = list(NULL), D = NULL)], ans)
+test(2264.75, copy(DT)[, let(L = list(NULL), D = NULL)], ans)
+test(2264.76, set(copy(DT), j = c("L", "D"), value = list(list(NULL), NULL)), ans)
+DT = data.table(L = list("A"), D = list("B"), i = 1L)
+# test for combining add, replace, remove in the same query
+ans = data.table(L = list(NULL), i = 1L, E = list(NULL))
+test(2264.77, copy(DT)[, c("L", "D", "E") := list(list(NULL), NULL, list(NULL))], ans)
+test(2264.78, copy(DT)[, `:=`(L = list(NULL), D = NULL, E = list(NULL))], ans)
+test(2264.79, copy(DT)[, let(L = list(NULL), D = NULL, E = list(NULL))], ans)
+test(2264.80, set(copy(DT), j = c("L", "D", "E"), value = list(list(NULL), NULL, list(NULL))), ans)