def get_result(self):
        what = self.expr.op()

        if self.memoize:
            self._memoize_tables()

        if isinstance(what, ops.TableNode) and what.has_schema():
            # This should also catch aggregations
            if not self.memoize and what in self.memo:
                text = 'Table: %s' % self.memo.get_alias(what)
            elif isinstance(what, ops.PhysicalTable):
                text = self._format_table(what)
            else:
                # Any other node type
                text = self._format_node(what)
        elif isinstance(what, ops.TableColumn):
            text = self._format_column(self.expr)
        elif isinstance(what, ir.Node):
            text = self._format_node(what)
        elif isinstance(what, ops.Literal):
            text = 'Literal[%s] %s' % (self._get_type_display(),
                                       str(what.value))

        if isinstance(self.expr, ir.ValueExpr) and self.expr._name is None:
            text = '{0} = {1}'.format(self.expr.get_name(), text)

        if self.memoize:
            alias_to_text = [(self.memo.aliases[x],
                              self.memo.formatted[x],
                              self.memo.ops[x])
                             for x in self.memo.formatted]
            alias_to_text.sort()

            # A hack to suppress printing out of a ref that is the result of
            # the top level expression
            refs = [x + '\n' + y
                    for x, y, op in alias_to_text
                    if not op.equals(what)]

            text = '\n\n'.join(refs + [text])

        return self._indent(text, self.base_level)
dataset/ETHPy150Open cloudera/ibis/ibis/expr/format.py/ExprFormatter.get_result/operator `is not` -> `is`