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
