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
