def when(self, case_expr, result_expr): """ Add a new case-result pair. Parameters ---------- case : Expr Expression to equality-compare with base expression. Must be comparable with the base. result : Expr Value when the case predicate evaluates to true. Returns ------- builder : CaseBuilder """ case_expr = as_value_expr(case_expr) result_expr = as_value_expr(result_expr) if not isinstance(case_expr, ir.BooleanValue): raise TypeError(case_expr) cases = list(self.cases) cases.append(case_expr) results = list(self.results) results.append(result_expr) # Maintain immutability return SearchedCaseBuilder(cases=cases, results=results, default=self.default)
def when(self, case_expr, result_expr): """ Add a new case-result pair. Parameters ---------- case : Expr Expression to equality-compare with base expression. Must be comparable with the base. result : Expr Value when the case predicate evaluates to true. Returns ------- builder : CaseBuilder """ case_expr = as_value_expr(case_expr) result_expr = as_value_expr(result_expr) if not self.base._can_compare(case_expr): raise TypeError('Base expression and passed case are not ' 'comparable') cases = list(self.cases) cases.append(case_expr) results = list(self.results) results.append(result_expr) # Maintain immutability return SimpleCaseBuilder(self.base, cases=cases, results=results, default=self.default)
def f(self, other): try: other = as_value_expr(other) op = klass(self, other) return op.to_expr() except (com.IbisTypeError, NotImplementedError): return NotImplemented
def f(self, other): try: other = as_value_expr(other) op = klass(self, other) return op.to_expr() except _com.InputTypeError: return NotImplemented
def test_series_to_ibis_literal(self): values = [1, 2, 3, 4] s = pd.Series(values) expr = ir.as_value_expr(s) expected = ir.sequence(list(s)) assert expr.equals(expected)
def test_series_to_ibis_literal(): values = [1, 2, 3, 4] s = dd.from_pandas(pd.Series(values), npartitions=1) expr = ir.as_value_expr(s) expected = ir.sequence(list(s)) assert expr.equals(expected)
def f(self, other): other = as_value_expr(other) if not isinstance(other, BooleanValue): raise TypeError(other) op = klass(other, self) return op.to_expr()
def mutate(table, exprs=None, **kwds): """ Convenience function for table projections involving adding columns Parameters ---------- exprs : list, default None List of named expressions to add as columns kwds : keywords for new columns Examples -------- expr = table.mutate(qux=table.foo + table.bar, baz=5) Returns ------- mutated : TableExpr """ if exprs is None: exprs = [] else: exprs = util.promote_list(exprs) for k, v in sorted(kwds.items()): if util.is_function(v): v = v(table) else: v = as_value_expr(v) exprs.append(v.name(k)) has_replacement = False for expr in exprs: if expr.get_name() in table: has_replacement = True if has_replacement: by_name = dict((x.get_name(), x) for x in exprs) used = set() proj_exprs = [] for c in table.columns: if c in by_name: proj_exprs.append(by_name[c]) used.add(c) else: proj_exprs.append(c) for x in exprs: if x.get_name() not in used: proj_exprs.append(x) return table.projection(proj_exprs) else: return table.projection([table] + exprs)
def else_(self, result_expr): """ Specify Returns ------- builder : CaseBuilder """ result_expr = as_value_expr(result_expr) # Maintain immutability return SearchedCaseBuilder(cases=list(self.cases), results=list(self.results), default=result_expr)
def validate(self, args, i): arg = args[i] if self.validator is not None: arg = args[i] = self.validator(arg) if arg is None: if not self.optional: return ir.as_value_expr(self.default) elif self.optional: return arg return self._validate(args, i)
def _validate(self, args, i): arg = args[i] if not isinstance(arg, list): arg = args[i] = list(arg) assert isinstance(arg, list), 'not a list in ListOf validation' if len(arg) < self.min_length: raise IbisTypeError('list must have at least {} elements'.format( self.min_length)) checked_args = [] for j in range(len(arg)): try: checked_arg = self.value_type.validate(arg, j) except IbisTypeError as e: exc = e.args[0] msg = ('List element {0} had a type error: {1}'.format(j, exc)) raise IbisTypeError(msg) checked_args.append(checked_arg) args[i] = checked_args return ir.as_value_expr(checked_args)
def __init__(self, value, options): self.value = as_value_expr(value) self.options = as_value_expr(options) BooleanValueOp.__init__(self, self.value, self.options)
def _validate(self, args, i): arg = args[i] if not isinstance(arg, ir.Expr): arg = args[i] = ir.as_value_expr(arg) return arg
def f(self, other): other = as_value_expr(other) op = klass(other, self) return op.to_expr()
def _between(arg, lower, upper): lower = as_value_expr(lower) upper = as_value_expr(upper) op = ms_ops.Between(arg, lower, upper) return op.to_expr()