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)