docs: def refresh(self, fetch_data):
          """ Redraw the display """
          self.win.erase()
          height, width = getmaxyx()
          if curses.is_term_resized(height, width):
              self.win.clear()
              curses.resizeterm(height, width)
          y = 1  # Starts at 1 because of date string
          x = 0
          columns = []
          column = []
          for table in self._tables:
              desc = self.engine.describe(table, fetch_data, True)
              line_count = 1 + 2 * len(desc.consumed_capacity)
              if (column or columns) and line_count + y > height:
                  columns.append(column)
                  column = []
                  y = 1
              y += line_count
              column.append(desc)
  
          columns.append(column)
          y = 1
  
          # Calculate the min width of each column
          column_widths = []
          for column in columns:
              column_widths.append(max(map(self._calc_min_width, column)))
          # Find how many columns we can support
          while len(columns) > 1 and sum(column_widths) > width - len(columns) + 1:
              columns.pop()
              column_widths.pop()
          effective_width = width - len(columns) + 1
          # Iteratively expand columns until we fit the width or they are all max
          while sum(column_widths) < effective_width and any(
              (w < self._max_width for w in column_widths)
          ):
              smallest = min(column_widths)
              i = column_widths.index(smallest)
              column_widths[i] += 1
  
          status = datetime.now().strftime("%H:%M:%S")
          status += " %d tables" % len(self._tables)
          num_displayed = sum(map(len, columns))
          if num_displayed < len(self._tables):
              status += " (%d visible)" % num_displayed
          self.win.addstr(0, 0, status[:width])
  
          for column, col_width in zip(columns, column_widths):
              for table in column:
                  cap = table.consumed_capacity["__table__"]
                  self.win.addstr(y, x, table.name, curses.color_pair(1))
                  self._add_throughput(
                      y + 1, x, col_width, "R", "", table.read_throughput, cap["read"]
                  )
                  self._add_throughput(
                      y + 2, x, col_width, "W", "", table.write_throughput, cap["write"]
                  )
                  y += 3
                  for index_name, cap in iteritems(table.consumed_capacity):
                      if index_name == "__table__":
                          continue
                      index = table.global_indexes[index_name]
                      self._add_throughput(
                          y,
                          x,
                          col_width,
                          "R",
                          index_name,
                          index.read_throughput,
                          cap["read"],
                      )
                      self._add_throughput(
                          y + 1,
                          x,
                          col_width,
                          "W",
                          index_name,
                          index.write_throughput,
                          cap["write"],
                      )
                      y += 2
              x += col_width + 1
              y = 1
  
          self.win.refresh()