Print Option: Print columns that fit in single console without wrapping

NEWS.md

@@ -8,6 +8,8 @@
 
 1. `DT[, {...; .(A,B)}]` (i.e. when `.()` is the final item of a multi-statement `{...}`) now auto-names the columns `A` and `B` (just like `DT[, .(A,B)]`) rather than `V1` and `V2`, [#2478](https://github.com/Rdatatable/data.table/issues/2478) [#609](https://github.com/Rdatatable/data.table/issues/609). Similarly, `DT[, if (.N>1) .(B), by=A]` now auto-names the column `B` rather than `V1`. Explicit names are unaffected; e.g. `DT[, {... y= ...; .(A=C+y)}, by=...]` named the column `A` before, and still does. Thanks also to @renkun-ken for his go-first strong testing which caught an issue not caught by the test suite or by revdep testing, related to NULL being the last item, [#4061](https://github.com/Rdatatable/data.table/issues/4061).
 
+2. `print` method for `data.table`s gains `trunc.cols` argument (and corresponding option `datatable.print.trunc.cols`, default `FALSE`), [#1497](https://github.com/Rdatatable/data.table/issues/1497), part of [#1523](https://github.com/Rdatatable/data.table/issues/1523). This argument makes it possible to print only as many columns as fit in the console without wrapping to new lines (e.g., the first 5 of 80 columns). In the case of truncation, a message is printed that states the count and the names of the variables not shown. When `class =  TRUE` in `print.data.table()`, the message also contains the classes of the variables. `data.table` has always automatically truncated _rows_ of a table for efficiency (e.g. printing 10 rows instead of 10 million); in the future, we may do the same for _columns_ (e.g., 10 columns instead of 20,000) by changing the default for this argument. Thanks to @nverno for the initial suggestion and to @TysonStanley for the PR.
+
 ## BUG FIXES
 
 ## NOTES

R/onLoad.R

@@ -71,14 +71,15 @@
   # In fread and fwrite we have moved back to using getOption's default argument since it is unlikely fread and fread will be called in a loop many times, plus they
   # are relatively heavy functions where the overhead in getOption() would not be noticed.  It's only really [.data.table where getOption default bit.
   # Improvement to base::getOption() now submitted (100x; 5s down to 0.05s):  https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17394
-  opts = c("datatable.verbose"="FALSE",            # datatable.<argument name>
+  opts = c("datatable.verbose"="FALSE",        # datatable.<argument name>
        "datatable.optimize"="Inf",             # datatable.<argument name>
        "datatable.print.nrows"="100L",         # datatable.<argument name>
        "datatable.print.topn"="5L",            # datatable.<argument name>
        "datatable.print.class"="FALSE",        # for print.data.table
        "datatable.print.rownames"="TRUE",      # for print.data.table
-       "datatable.print.colnames"="'auto'",      # for print.data.table
+       "datatable.print.colnames"="'auto'",    # for print.data.table
        "datatable.print.keys"="FALSE",         # for print.data.table
+       "datatable.print.trunc.cols"="FALSE",   # for print.data.table
        "datatable.allow.cartesian"="FALSE",    # datatable.<argument name>
        "datatable.dfdispatchwarn"="TRUE",                   # not a function argument
        "datatable.warnredundantby"="TRUE",                  # not a function argument

R/print.data.table.R

@@ -6,11 +6,13 @@ print.data.table = function(x, topn=getOption("datatable.print.topn"),
                row.names=getOption("datatable.print.rownames"),
                col.names=getOption("datatable.print.colnames"),
                print.keys=getOption("datatable.print.keys"),
+               trunc.cols=getOption("datatable.print.trunc.cols"),
                quote=FALSE,
                timezone=FALSE, ...) {
   # topn  - print the top topn and bottom topn rows with '---' inbetween (5)
   # nrows - under this the whole (small) table is printed, unless topn is provided (100)
   # class - should column class be printed underneath column name? (FALSE)
+  # trunc.cols - should only the columns be printed that can fit in the console? (FALSE)
   if (!col.names %chin% c("auto", "top", "none"))
     stop("Valid options for col.names are 'auto', 'top', and 'none'")
   if (col.names == "none" && class)
@@ -87,7 +89,22 @@ print.data.table = function(x, topn=getOption("datatable.print.topn"),
     toprint = rbind(abbs, toprint)
     rownames(toprint)[1L] = ""
   }
+  if (isFALSE(class) || (isTRUE(class) && col.names == "none")) abbs = ""
   if (quote) colnames(toprint) <- paste0('"', old <- colnames(toprint), '"')
+  if (isTRUE(trunc.cols)) {
+    # allow truncation of columns to print only what will fit in console PR #4074
+    widths = dt_width(toprint, class, row.names, col.names)
+    cons_width = getOption("width")
+    cols_to_print = widths < cons_width
+    not_printed = colnames(toprint)[!cols_to_print]
+    if (!any(cols_to_print)) {
+      trunc_cols_message(not_printed, abbs, class, col.names)
+      return(invisible(x))
+    }
+    # When nrow(toprint) = 1, attributes get lost in the subset,
+    #   function below adds those back when necessary
+    toprint = toprint_subset(toprint, cols_to_print)
+  }
   if (printdots) {
     toprint = rbind(head(toprint, topn + isTRUE(class)), "---"="", tail(toprint, topn))
     rownames(toprint) = format(rownames(toprint), justify="right")
@@ -96,6 +113,10 @@ print.data.table = function(x, topn=getOption("datatable.print.topn"),
     } else {
       print(toprint, right=TRUE, quote=quote)
     }
+    if (trunc.cols && length(not_printed) > 0L)
+      # prints names of variables not shown in the print
+      trunc_cols_message(not_printed, abbs, class, col.names)
+
     return(invisible(x))
   }
   if (nrow(toprint)>20L && col.names == "auto")
@@ -107,6 +128,10 @@ print.data.table = function(x, topn=getOption("datatable.print.topn"),
   } else {
     print(toprint, right=TRUE, quote=quote)
   }
+  if (trunc.cols && length(not_printed) > 0L)
+    # prints names of variables not shown in the print
+    trunc_cols_message(not_printed, abbs, class, col.names)
+
   invisible(x)
 }
 
@@ -164,3 +189,39 @@ shouldPrint = function(x) {
 #   as opposed to printing a blank line, for excluding col.names per PR #1483
 cut_top = function(x) cat(capture.output(x)[-1L], sep = '\n')
 
+# to calculate widths of data.table for PR #4074
+# gets the width of the data.table at each column
+#   and compares it to the console width
+dt_width = function(x, class, row.names, col.names) {
+  widths = apply(nchar(x, type='width'), 2L, max)
+  if (class) widths = pmax(widths, 6L)
+  if (col.names != "none") names = sapply(colnames(x), nchar, type = "width") else names = 0L
+  dt_widths = pmax(widths, names)
+  rownum_width = if (row.names) as.integer(ceiling(log10(nrow(x)))+2) else 0L
+  cumsum(dt_widths + 1L) + rownum_width
+}
+# keeps the dim and dimnames attributes
+toprint_subset = function(x, cols_to_print) {
+  if (nrow(x) == 1L){
+    atts = attributes(x)
+    atts$dim = c(1L, sum(cols_to_print))
+    atts$dimnames[[2L]] = atts$dimnames[[2L]][cols_to_print]
+    x = x[, cols_to_print, drop=FALSE]
+    attributes(x) = atts
+    x
+  } else {
+    x[, cols_to_print, drop=FALSE]
+  }
+}
+# message for when trunc.cols=TRUE and some columns are not printed
+trunc_cols_message = function(not_printed, abbs, class, col.names){
+  n = length(not_printed)
+  if (class && col.names != "none") classes = paste0(" ", tail(abbs, n)) else classes = ""
+  cat(sprintf(
+    ngettext(n,
+             "%d variable not shown: %s\n",
+             "%d variables not shown: %s\n"),
+    n, brackify(paste0(not_printed, classes))
+  ))
+}
+

inst/tests/tests.Rraw

@@ -16382,6 +16382,86 @@ test(2121.5, DT[, .(.N=.N), by=a], data.table(a=c(1,2), .N=2:1)) # user supplied
 test(2121.6, DT[ , {.(a, b=b+1); NULL}], NULL)
 
 
+# trunc.cols in print.data.table #4074
+old_width = options("width" = 40)
+# Single row printing (to check issue with losing attributes)
+DT = data.table(a = "aaaaaaaaaaaaa",
+                b = "bbbbbbbbbbbbb",
+                c = "ccccccccccccc",
+                d = "ddddddddddddd")
+
+test(2122.01,
+     capture.output(print(DT, trunc.cols=TRUE))[3],
+     "2 variables not shown: [c, d]")
+# Printing with dots
+DT = data.table(a = vector("integer", 102),
+                b = "bbbbbbbbbbbbb",
+                c = "ccccccccccccc",
+                d = c("ddddddddddddd", "d"))
+test(2122.02, capture.output(print(DT, trunc.cols=TRUE)),
+     c("     a             b             c",
+       "  1: 0 bbbbbbbbbbbbb ccccccccccccc",
+       "  2: 0 bbbbbbbbbbbbb ccccccccccccc",
+       "  3: 0 bbbbbbbbbbbbb ccccccccccccc",
+       "  4: 0 bbbbbbbbbbbbb ccccccccccccc",
+       "  5: 0 bbbbbbbbbbbbb ccccccccccccc",
+       " ---                              ",
+       " 98: 0 bbbbbbbbbbbbb ccccccccccccc",
+       " 99: 0 bbbbbbbbbbbbb ccccccccccccc",
+       "100: 0 bbbbbbbbbbbbb ccccccccccccc",
+       "101: 0 bbbbbbbbbbbbb ccccccccccccc",
+       "102: 0 bbbbbbbbbbbbb ccccccccccccc",
+       "1 variable not shown: [d]"))
+
+test(2122.03, capture.output(print(DT, trunc.cols=TRUE, row.names=FALSE)),
+     c("    a             b             c",
+       "    0 bbbbbbbbbbbbb ccccccccccccc",
+       "    0 bbbbbbbbbbbbb ccccccccccccc",
+       "    0 bbbbbbbbbbbbb ccccccccccccc",
+       "    0 bbbbbbbbbbbbb ccccccccccccc",
+       "    0 bbbbbbbbbbbbb ccccccccccccc",
+       "---                              ",
+       "    0 bbbbbbbbbbbbb ccccccccccccc",
+       "    0 bbbbbbbbbbbbb ccccccccccccc",
+       "    0 bbbbbbbbbbbbb ccccccccccccc",
+       "    0 bbbbbbbbbbbbb ccccccccccccc",
+       "    0 bbbbbbbbbbbbb ccccccccccccc",
+       "1 variable not shown: [d]" ))
+
+test(2122.04, capture.output(print(DT, trunc.cols=TRUE, class=TRUE))[14],
+     "1 variable not shown: [d <char>]")
+test(2122.05, capture.output(print(DT, trunc.cols=TRUE, class=TRUE, row.names=FALSE))[c(1,14)],
+     c("        a             b             c",
+       "1 variable not shown: [d <char>]" ))
+test(2122.06, capture.output(print(DT, trunc.cols=TRUE, col.names="none"))[c(1,12)],
+     c("  1: 0 bbbbbbbbbbbbb ccccccccccccc",
+       "1 variable not shown: [d]" ))
+test(2122.07, capture.output(print(DT, trunc.cols=TRUE, class=TRUE, col.names="none"))[c(1,13)],
+     c("  1: 0 bbbbbbbbbbbbb ccccccccccccc",
+       "1 variable not shown: [d]" ),
+     warning = "Column classes will be suppressed when col.names is 'none'")
+options("width" = 20)
+DT = data.table(a = vector("integer", 2),
+                b = "bbbbbbbbbbbbb",
+                c = "ccccccccccccc",
+                d = "ddddddddddddd")
+test(2122.08, capture.output(print(DT, trunc.cols=TRUE)),
+     c("   a             b",
+       "1: 0 bbbbbbbbbbbbb",
+       "2: 0 bbbbbbbbbbbbb",
+       "2 variables not shown: [c, d]"))
+options("width" = 10)
+DT = data.table(a = "aaaaaaaaaaaaa",
+                b = "bbbbbbbbbbbbb",
+                c = "ccccccccccccc",
+                d = "ddddddddddddd")
+test(2122.09, capture.output(print(DT, trunc.cols=TRUE)),
+     "4 variables not shown: [a, b, c, d]")
+test(2122.10, capture.output(print(DT, trunc.cols=TRUE, class=TRUE)),
+     "4 variables not shown: [a <char>, b <char>, c <char>, d <char>]")
+options(old_width)
+
+
 ###################################
 #  Add new tests above this line  #
 ###################################

man/print.data.table.Rd

@@ -8,12 +8,13 @@
 }
 \usage{
   \method{print}{data.table}(x,
-    topn=getOption("datatable.print.topn"),          # default: 5
-    nrows=getOption("datatable.print.nrows"),        # default: 100
-    class=getOption("datatable.print.class"),  # default: FALSE
-    row.names=getOption("datatable.print.rownames"), # default: TRUE
-    col.names=getOption("datatable.print.colnames"), # default: "auto"
-    print.keys=getOption("datatable.print.keys"),    # default: FALSE
+    topn=getOption("datatable.print.topn"),             # default: 5
+    nrows=getOption("datatable.print.nrows"),           # default: 100
+    class=getOption("datatable.print.class"),           # default: FALSE
+    row.names=getOption("datatable.print.rownames"),    # default: TRUE
+    col.names=getOption("datatable.print.colnames"),    # default: "auto"
+    print.keys=getOption("datatable.print.keys"),       # default: FALSE
+    trunc.cols=getOption("datatable.print.trunc.cols"), # default: FALSE
     quote=FALSE,
     timezone=FALSE, \dots)
 }
@@ -25,6 +26,7 @@
   \item{row.names}{ If \code{TRUE}, row indices will be printed alongside \code{x}. }
   \item{col.names}{ One of three flavours for controlling the display of column names in output. \code{"auto"} includes column names above the data, as well as below the table if \code{nrow(x) > 20}. \code{"top"} excludes this lower register when applicable, and \code{"none"} suppresses column names altogether (as well as column classes if \code{class = TRUE}. }
   \item{print.keys}{ If \code{TRUE}, any \code{\link{key}} and/or \code{\link[=indices]{index}} currently assigned to \code{x} will be printed prior to the preview of the data. }
+  \item{trunc.cols}{ If \code{TRUE}, only the columns that can be printed in the console without wrapping the columns to new lines will be printed (similar to \code{tibbles}). }
   \item{quote}{ If \code{TRUE}, all output will appear in quotes, as in \code{print.default}. }
   \item{timezone}{ If \code{TRUE}, time columns of class POSIXct or POSIXlt will be printed with their timezones (if attribute is available). }
   \item{\dots}{ Other arguments ultimately passed to \code{format}. }
@@ -58,5 +60,17 @@
   setindexv(DT, c("a", "b"))
   setindexv(DT, "a")
   print(DT, print.keys=TRUE)
+
+  # `trunc.cols` will make it so only columns that fit in console will be printed
+  #    with a message that states the variables not shown
+  old_width = options("width" = 40)
+  DT <- data.table(thing_11 = vector("integer", 3),
+                   thing_21 = vector("complex", 3),
+                   thing_31 = as.IDate(paste0("2016-02-0", 1:3)),
+                   thing_41 = "aasdfasdfasdfasdfasdfasdfasdfasdfasdfasdf",
+                   thing_51 = vector("integer", 3),
+                   thing_61 = vector("complex", 3))
+  print(DT, trunc.cols=TRUE)
+  options(old_width)
 }