def __init__(self, table, metrics, by, having, predicates, sort_keys):
from ibis.expr.analysis import shares_all_roots, shares_some_roots
# All non-scalar refs originate from the input table
if not shares_all_roots(metrics + by + having + sort_keys, table):
raise com.RelationError(
"Selection expressions don't fully originate from "
"dependencies of the table expression.")
# invariant due to Aggregation and AggregateSelection requiring a valid
# Selection
assert all(
shares_some_roots(predicate, table) for predicate in predicates)
if not by:
sort_keys = tuple()
super().__init__(
table=table,
metrics=metrics,
by=by,
having=having,
predicates=predicates,
sort_keys=sort_keys,
)
# Validate schema has no overlapping columns
assert self.schema
def _validate_join_predicates(left, right, predicates):
from ibis.expr.analysis import shares_all_roots
# Validate join predicates. Each predicate must be valid jointly when
# considering the roots of each input table
for predicate in predicates:
if not shares_all_roots(predicate, [left, right]):
raise com.RelationError('The expression {!r} does not fully '
'originate from dependencies of the table '
'expression.'.format(predicate))
def to_projection(self):
"""
Promote this column expression to a table projection
"""
roots = self._root_tables()
if len(roots) > 1:
raise com.RelationError('Cannot convert array expression '
'involving multiple base table references '
'to a projection')
table = TableExpr(roots[0])
return table.projection([self])
def to_projection(self) -> ir.Table:
"""Promote this column expression to a projection."""
from ibis.expr.types.relations import Table
roots = self.op().root_tables()
if len(roots) > 1:
raise com.RelationError(
'Cannot convert array expression involving multiple base '
'table references to a projection')
table = Table(roots[0])
return table.projection([self])
def __init__(self, table, selections, predicates, sort_keys, **kwargs):
from ibis.expr.analysis import shares_all_roots, shares_some_roots
if not shares_all_roots(selections + sort_keys, table):
raise com.RelationError(
"Selection expressions don't fully originate from "
"dependencies of the table expression.")
for predicate in predicates:
if not shares_some_roots(predicate, table):
raise com.RelationError(
"Predicate doesn't share any roots with table")
super().__init__(
table=table,
selections=selections,
predicates=predicates,
sort_keys=sort_keys,
**kwargs,
)
# Validate no overlapping columns in schema
assert self.schema
def _format_table(self, expr):
# TODO: This could probably go in a class and be significantly nicer
ctx = self.context
ref_expr = expr
op = ref_op = expr.op()
if isinstance(op, ops.SelfReference):
ref_expr = op.table
ref_op = ref_expr.op()
if isinstance(ref_op, ops.PhysicalTable):
name = ref_op.name
if name is None:
raise com.RelationError(
'Table did not have a name: {0!r}'.format(expr))
result = self._quote_identifier(name)
is_subquery = False
else:
# A subquery
if ctx.is_extracted(ref_expr):
# Was put elsewhere, e.g. WITH block, we just need to grab its
# alias
alias = ctx.get_ref(expr)
# HACK: self-references have to be treated more carefully here
if isinstance(op, ops.SelfReference):
return '{} {}'.format(ctx.get_ref(ref_expr), alias)
else:
return alias
subquery = ctx.get_compiled_expr(expr)
result = '(\n{}\n)'.format(util.indent(subquery, self.indent))
is_subquery = True
if is_subquery or ctx.need_aliases(expr):
result += ' {}'.format(ctx.get_ref(expr))
return result
def __init__(self, left, right, **kwargs):
if not left.schema().equals(right.schema()):
raise com.RelationError(
'Table schemas must be equal for set operations')
super().__init__(left=left, right=right, **kwargs)
