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 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 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 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 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 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 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 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()
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()
