def test_invalid_date_arithmetics():
d1 = api.date('2015-01-02')
i1 = api.interval(seconds=300)
i2 = api.interval(minutes=15)
i3 = api.interval(hours=1)
for i in [i1, i2, i3]:
with pytest.raises(TypeError):
d1 - i
with pytest.raises(TypeError):
d1 + i
def test_time_arithmetics():
t1 = api.time('18:00')
t2 = api.time('19:12')
i1 = api.interval(minutes=3)
for expr in [t1 - t2, t2 - t1]:
assert isinstance(expr, ir.IntervalScalar)
assert isinstance(expr.op(), ops.TimeDiff)
assert expr.type() == dt.Interval('s', dt.int32)
for expr in [t1 - i1, t2 - i1]:
assert isinstance(expr, ir.TimeScalar)
assert isinstance(expr.op(), ops.TimeSub)
for expr in [t1 + i1, t2 + i1]:
assert isinstance(expr, ir.TimeScalar)
assert isinstance(expr.op(), ops.TimeAdd)
def test_date_arithmetics():
d1 = api.date('2015-01-02')
d2 = api.date('2017-01-01')
i1 = api.interval(weeks=3)
for expr in [d1 - d2, d2 - d1]:
assert isinstance(expr, ir.IntervalScalar)
assert isinstance(expr.op(), ops.DateDiff)
assert expr.type() == dt.Interval('D', dt.int32)
for expr in [d1 - i1, d2 - i1]:
assert isinstance(expr, ir.DateScalar)
assert isinstance(expr.op(), ops.DateSub)
for expr in [d1 + i1, d2 + i1]:
assert isinstance(expr, ir.DateScalar)
assert isinstance(expr.op(), ops.DateAdd)
def test_timestamp_arithmetics():
ts1 = api.timestamp(datetime.datetime.now())
ts2 = api.timestamp(datetime.datetime.today())
i1 = api.interval(minutes=30)
# TODO: raise for unsupported operations too
for expr in [ts2 - ts1, ts1 - ts2]:
assert isinstance(expr, ir.IntervalScalar)
assert isinstance(expr.op(), ops.TimestampDiff)
assert expr.type() == dt.Interval('s', dt.int32)
for expr in [ts1 - i1, ts2 - i1]:
assert isinstance(expr, ir.TimestampScalar)
assert isinstance(expr.op(), ops.TimestampSub)
for expr in [ts1 + i1, ts2 + i1]:
assert isinstance(expr, ir.TimestampScalar)
assert isinstance(expr.op(), ops.TimestampAdd)
def test_interval_timestamp_expr(table):
c = table.i
x = api.interval(seconds=1)
expr = x + c
assert isinstance(expr, ir.TimestampColumn)
assert isinstance(expr.op(), ops.TimestampAdd)
# test radd
expr = c + x
assert isinstance(expr, ir.TimestampColumn)
assert isinstance(expr.op(), ops.TimestampAdd)
expr = x - c
assert isinstance(expr, ir.TimestampColumn)
assert isinstance(expr.op(), ops.TimestampSub)
# test radd
expr = c - x
assert isinstance(expr, ir.TimestampColumn)
assert isinstance(expr.op(), ops.TimestampSub)
def test_interval_date_expr(table):
c = table.j
x = api.interval(days=1)
expr = x + c
assert isinstance(expr, ir.DateColumn)
assert isinstance(expr.op(), ops.DateAdd)
# test radd
expr = c + x
assert isinstance(expr, ir.DateColumn)
assert isinstance(expr.op(), ops.DateAdd)
expr = x - c
assert isinstance(expr, ir.DateColumn)
assert isinstance(expr.op(), ops.DateSub)
# test radd
expr = c - x
assert isinstance(expr, ir.DateColumn)
assert isinstance(expr.op(), ops.DateSub)
def test_interval_time_expr(table):
c = table.k
x = api.interval(hours=1)
expr = x + c
assert isinstance(expr, ir.TimeColumn)
assert isinstance(expr.op(), ops.TimeAdd)
# test radd
expr = c + x
assert isinstance(expr, ir.TimeColumn)
assert isinstance(expr.op(), ops.TimeAdd)
expr = x - c
assert isinstance(expr, ir.TimeColumn)
assert isinstance(expr.op(), ops.TimeSub)
# test radd
expr = c - x
assert isinstance(expr, ir.TimeColumn)
assert isinstance(expr.op(), ops.TimeSub)
def test_interval_properties(prop, expected_unit):
i = api.interval(seconds=3600)
assert getattr(i, prop).type().unit == expected_unit
import ibis.expr.operations as ops
import ibis.expr.types as ir
def test_temporal_literals():
date = ibis.literal('2015-01-01', 'date')
assert isinstance(date, ir.DateScalar)
timestamp = ibis.literal('2017-01-01 12:00:33', 'timestamp')
assert isinstance(timestamp, ir.TimestampScalar)
@pytest.mark.parametrize(
('interval', 'unit', 'expected'),
[
(api.interval(months=3), 'Q', api.interval(quarters=1)),
(api.interval(months=12), 'Y', api.interval(years=1)),
(api.interval(quarters=8), 'Y', api.interval(years=2)),
(api.interval(days=14), 'W', api.interval(weeks=2)),
(api.interval(minutes=240), 'h', api.interval(hours=4)),
(api.interval(seconds=360), 'm', api.interval(minutes=6)),
(api.interval(seconds=3 * 86400), 'D', api.interval(days=3)),
(api.interval(milliseconds=5000), 's', api.interval(seconds=5)),
(api.interval(microseconds=5000000), 's', api.interval(seconds=5)),
(api.interval(nanoseconds=5000000000), 's', api.interval(seconds=5)),
],
)
def test_upconvert(interval, unit, expected):
result = interval.to_unit(unit)
assert isinstance(result, ir.IntervalScalar)
def test_downconvert_day(case, expected):
assert isinstance(case, ir.IntervalScalar)
assert isinstance(expected, ir.IntervalScalar)
assert case.unit == expected.unit
@pytest.mark.parametrize(('a', 'b', 'unit'),
[(api.day(), api.day(3), 'D'),
(api.second(), api.hour(10), 's'),
(api.hour(3), api.day(2), 'h')])
def test_combine_with_different_kinds(a, b, unit):
assert (a + b).type().unit == unit
@pytest.mark.parametrize(('case', 'expected'), [
(api.interval(quarters=2), api.quarter(2)),
(api.interval(weeks=2), api.week(2)),
(api.interval(days=3), api.day(3)),
(api.interval(hours=4), api.hour(4)),
(api.interval(minutes=5), api.minute(5)),
(api.interval(seconds=6), api.second(6)),
(api.interval(milliseconds=7), api.millisecond(7)),
(api.interval(microseconds=8), api.microsecond(8)),
(api.interval(nanoseconds=9), api.nanosecond(9)),
])
def test_timedelta_generic_api(case, expected):
assert case.equals(expected)
def test_interval_time_expr(table):
c = table.k
