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()
Redraw the display