def _clean_predicates(self, predicates): import ibis.expr.analysis as L result = [] if not isinstance(predicates, (list, tuple)): predicates = [predicates] for pred in predicates: if isinstance(pred, tuple): if len(pred) != 2: raise com.ExpressionError('Join key tuple must be ' 'length 2') lk, rk = pred lk = self.left._ensure_expr(lk) rk = self.right._ensure_expr(rk) pred = lk == rk else: pred = L.substitute_parents(pred, past_projection=False) if not isinstance(pred, ir.BooleanArray): raise com.ExpressionError('Join predicate must be comparison') preds = L.unwrap_ands(pred) result.extend(preds) return result
def __init__(self, table): if not isinstance(table, TableExpr): raise com.ExpressionError('Requires table') schema = table.schema() if len(schema) > 1: raise com.ExpressionError('Table can only have a single column') self.table = table self.name = schema.names[0] Node.__init__(self, [table])
def _validate(self): # All aggregates are valid for expr in self.agg_exprs: if not rules.is_scalar(expr) or not is_reduction(expr): raise TypeError('Passed a non-aggregate expression: %s' % _safe_repr(expr)) for expr in self.having: if not isinstance(expr, ir.BooleanScalar): raise com.ExpressionError('Having clause must be boolean ' 'expression, was: {0!s}'.format( _safe_repr(expr))) # All non-scalar refs originate from the input table all_exprs = self.agg_exprs + self.by + self.having self.table._assert_valid(all_exprs)
def __len__(self): raise com.ExpressionError('Use .count() instead')
def resolve_name(self): raise com.ExpressionError('Expression is not named: %s' % repr(self))
def __init__(self, expr, ascending=True): if not rules.is_array(expr): raise com.ExpressionError('Must be an array/column expression') self.expr = expr self.ascending = ascending