def _lift_TableColumn(self, expr, block=None): node = expr.op() root = node.table.op() result = expr if isinstance(root, ops.Selection): can_lift = False all_simple_columns = all( isinstance(sel.op(), ops.TableColumn) and sel.op().name == sel.get_name() for sel in root.selections if isinstance(sel, ir.ValueExpr) if sel.has_name()) for val in root.selections: value_op = val.op() if (isinstance(value_op, ops.PhysicalTable) and node.name in val.schema()): can_lift = True lifted_root = self.lift(val) elif (all_simple_columns and isinstance(val, ir.ValueExpr) and val.has_name() and node.name == val.get_name()): can_lift = True lifted_root = self.lift(value_op.table) if can_lift and not block: lifted_node = ops.TableColumn(node.name, lifted_root) result = expr._factory(lifted_node, name=expr._name) return result
def _lift_TableColumn(self, expr, block=None): node = expr.op() tnode = node.table.op() root = _base_table(tnode) result = expr if isinstance(root, ops.Selection): can_lift = False for val in root.selections: if (isinstance(val.op(), ops.PhysicalTable) and node.name in val.schema()): can_lift = True lifted_root = self.lift(val) elif (isinstance(val.op(), ops.TableColumn) and val.op().name == val.get_name() and node.name == val.get_name()): can_lift = True lifted_root = self.lift(val.op().table) # XXX # can_lift = False # HACK: If we've projected a join, do not lift the children # TODO: what about limits and other things? # if isinstance(root.table.op(), Join): # can_lift = False if can_lift and not block: lifted_node = ops.TableColumn(node.name, lifted_root) result = expr._factory(lifted_node, name=expr._name) return result
def _lift_TableColumn(self, expr, block=None): node = expr.op() root = node.table.op() result = expr if isinstance(root, ops.Selection): can_lift = False all_simple_columns = all( isinstance(sel.op(), ops.TableColumn) and sel.op().name == sel.get_name() for sel in root.selections if isinstance(sel, ir.ValueExpr) if sel.has_name()) # If there are predicates or sort keys, # then we cannot lift the root no_predicates_or_sort_keys = not (root.predicates or root.sort_keys) for val in root.selections: value_op = val.op() if (isinstance(value_op, ops.PhysicalTable) and node.name in val.schema()): can_lift = True lifted_root = self.lift(val) elif (all_simple_columns and no_predicates_or_sort_keys and isinstance(val, ir.ValueExpr) and val.has_name() and node.name == val.get_name()): can_lift = True lifted_root = self.lift(value_op.table) if can_lift and not block: lifted_node = ops.TableColumn(lifted_root, node.name) result = expr._factory(lifted_node, name=expr._name) return result
def get_column(self, name): """ Get a reference to a single column from the table Returns ------- column : array expression """ import ibis.expr.operations as ops ref = ops.TableColumn(name, self) return ref.to_expr()
def get_column(self, name: str) -> ColumnExpr: """Get a reference to a single column from the table. Returns ------- ColumnExpr A column named `name`. """ import ibis.expr.operations as ops ref = ops.TableColumn(self, name) return ref.to_expr()
def _lift_TableColumn(self, expr, block=None): node = expr.op() root = node.table.op() result = expr if isinstance(root, ops.Selection): can_lift = False for val in root.selections: value_op = val.op() if (isinstance(value_op, ops.PhysicalTable) and node.name in val.schema()): can_lift = True lifted_root = self.lift(val) if can_lift and not block: lifted_node = ops.TableColumn(lifted_root, node.name) result = type(expr)(lifted_node) return result
def fn(node): if isinstance(node, ops.Selection): # stop substituting child nodes return lin.halt elif isinstance(node, ops.TableColumn): # For table column references, in the event that we're on top of a # projection, we need to check whether the ref comes from the base # table schema or is a derived field. If we've projected out of # something other than a physical table, then lifting should not # occur table = node.table.op() if isinstance(table, ops.Selection): for val in table.selections: if (isinstance(val.op(), ops.PhysicalTable) and node.name in val.schema()): return ops.TableColumn(val, node.name).to_expr() # keep looking for nodes to substitute return lin.proceed