Esempio n. 1
0
def test_simple_datetime_operations(con, func, expected):
    value = ibis.timestamp('2015-09-01 14:48:05.359')
    with pytest.raises(ValueError):
        con.execute(func(value))

    value = ibis.timestamp('2015-09-01 14:48:05')
    con.execute(func(value)) == expected
Esempio n. 2
0
def test_simple_datetime_operations(con, func, expected):
    value = ibis.timestamp('2015-09-01 14:48:05.359')
    with pytest.raises(ValueError):
        con.execute(func(value))

    value = ibis.timestamp('2015-09-01 14:48:05')
    con.execute(func(value)) == expected
Esempio n. 3
0
def test_timestamp_integer_warns():
    with pytest.warns(UserWarning):
        ibis.timestamp(1234)

    t = ibis.table([('ts', 'timestamp')])
    column = t.ts
    with pytest.warns(UserWarning):
        column < 1234
Esempio n. 4
0
    def test_udf_primitive_output_types(self):
        types = [
            ('boolean', True, self.b),
            ('int8', 1, self.i8),
            ('int16', 1, self.i16),
            ('int32', 1, self.i32),
            ('int64', 1, self.i64),
            ('float', 1.0, self.f),
            ('double', 1.0, self.d),
            ('string', '1', self.s),
            ('timestamp', ibis.timestamp('1961-04-10'), self.t),
        ]
        for t, sv, av in types:
            func = self._register_udf([t], t, 'test')

            ibis_type = dt.validate_type(t)

            expr = func(sv)
            assert type(expr) == type(
                ibis_type.scalar_type()(expr.op())
            )  # noqa: E501, E721
            expr = func(av)
            assert type(expr) == type(
                ibis_type.column_type()(expr.op())
            )  # noqa: E501, E721
Esempio n. 5
0
    def test_udf_primitive_output_types(self):
        types = [
            ('boolean', True, self.b),
            ('int8', 1, self.i8),
            ('int16', 1, self.i16),
            ('int32', 1, self.i32),
            ('int64', 1, self.i64),
            ('float', 1.0, self.f),
            ('double', 1.0, self.d),
            ('string', '1', self.s),
            ('timestamp', ibis.timestamp('1961-04-10'), self.t),
        ]
        for t, sv, av in types:
            func = self._register_udf([t], t, 'test')

            ibis_type = dt.validate_type(t)

            expr = func(sv)
            assert type(expr) == type(
                ibis_type.scalar_type()(expr.op())
            )  # noqa: E501, E721
            expr = func(av)
            assert type(expr) == type(
                ibis_type.column_type()(expr.op())
            )  # noqa: E501, E721
Esempio n. 6
0
 def test_timestamp_wrapping(self):
     func = self._udf_registration_single_input('timestamp',
                                                'timestamp',
                                                'test')
     expr = func(ibis.timestamp('1961-04-10'))
     assert type(expr) == ir.TimestampScalar
     expr = func(self.t)
     assert type(expr) == ir.TimestampArray
Esempio n. 7
0
def test_timestamp_scalar_in_filter(alltypes, translate):
    table = alltypes

    expr = (table.filter([
        table.timestamp_col < (ibis.timestamp('2010-01-01') + ibis.week(3)),
        table.timestamp_col < (ibis.now() + ibis.day(10))
    ]).count())
    expr.execute()
Esempio n. 8
0
    def test_timestamp_literals(self):
        tv1 = '2015-01-01 12:34:56'
        ex1 = ("'2015-01-01 12:34:56'")

        cases = [(ibis.literal(pd.Timestamp(tv1)), ex1),
                 (ibis.literal(pd.Timestamp(tv1).to_pydatetime()), ex1),
                 (ibis.timestamp(tv1), ex1)]
        self._check_expr_cases(cases)
Esempio n. 9
0
def test_strftime(con, func):
    value = ibis.timestamp('2015-09-01 14:48:05.359')
    raw_value = datetime(
        year=2015, month=9, day=1,
        hour=14, minute=48, second=5, microsecond=359000
    )

    assert con.execute(func(value)) == func(raw_value)
def test_large_timestamp(client):
    huge_timestamp = datetime.datetime(2012, 10, 10, 10, 10, 10, 154117)
    expr = ibis.timestamp("2012-10-10 10:10:10.154117")
    result = client.execute(expr)

    huge_timestamp = (pd.to_datetime(huge_timestamp).tz_localize("UTC")).date()
    result = (result["tmp"][0]).date()
    assert result == huge_timestamp
Esempio n. 11
0
def test_timestamp_scalar_in_filter(alltypes, translate):
    table = alltypes

    expr = table.filter([
        table.timestamp_col <
        (ibis.timestamp('2010-01-01') + ibis.interval(weeks=3)),
        table.timestamp_col < (ibis.now() + ibis.interval(days=10)),
    ]).count()
    expr.execute()
Esempio n. 12
0
    def test_timestamp_scalar_in_filter(self):
        # #310
        table = self.alltypes

        expr = (table.filter([table.timestamp_col <
                             (ibis.timestamp('2010-01-01') + ibis.month(3)),
                             table.timestamp_col < (ibis.now() + ibis.day(10))
                              ])
                .count())
        expr.execute()
Esempio n. 13
0
    def test_mult_args(self):
        func = self._register_udf(['int32', 'double', 'string',
                                   'boolean', 'timestamp'],
                                  'int64', 'mult_types')

        expr = func(self.i32, self.d, self.s, self.b, self.t)
        assert issubclass(type(expr), ir.ArrayExpr)

        expr = func(1, 1.0, 'a', True, ibis.timestamp('1961-04-10'))
        assert issubclass(type(expr), ir.ScalarExpr)
Esempio n. 14
0
    def test_timestamp_literals(self):
        tv1 = '2015-01-01 12:34:56'
        ex1 = ("'2015-01-01 12:34:56'")

        cases = [
            (ibis.literal(pd.Timestamp(tv1)), ex1),
            (ibis.literal(pd.Timestamp(tv1).to_pydatetime()), ex1),
            (ibis.timestamp(tv1), ex1)
        ]
        self._check_expr_cases(cases)
Esempio n. 15
0
def test_timestamp_scalar_in_filter(alltypes):
    # #310
    table = alltypes

    expr = table.filter([
        table.timestamp_col <
        (ibis.timestamp('2010-01-01') + ibis.interval(months=3)),
        table.timestamp_col < (ibis.now() + ibis.interval(days=10)),
    ]).count()
    expr.execute()
Esempio n. 16
0
    def test_timestamp_literals(self):
        from pandas import Timestamp

        tv1 = '2015-01-01 12:34:56'
        ex1 = ("'2015-01-01 12:34:56'")

        cases = [(L(Timestamp(tv1)), ex1),
                 (L(Timestamp(tv1).to_pydatetime()), ex1),
                 (ibis.timestamp(tv1), ex1)]
        self._check_expr_cases(cases)
Esempio n. 17
0
    def test_mult_args(self):
        func = self._register_udf(['int32', 'double', 'string',
                                   'boolean', 'timestamp'],
                                  'int64', 'mult_types')

        expr = func(self.i32, self.d, self.s, self.b, self.t)
        assert issubclass(type(expr), ir.ColumnExpr)

        expr = func(1, 1.0, 'a', True, ibis.timestamp('1961-04-10'))
        assert issubclass(type(expr), ir.ScalarExpr)
Esempio n. 18
0
    def test_timestamp_scalar_in_filter(self):
        # #310
        table = self.alltypes

        expr = (table.filter([table.timestamp_col <
                             (ibis.timestamp('2010-01-01') + ibis.month(3)),
                             table.timestamp_col < (ibis.now() + ibis.day(10))
                              ])
                .count())
        expr.execute()
Esempio n. 19
0
    def test_timestamp_literals(self):
        ts_str = '2015-01-01 00:00:00'
        val = pd.Timestamp(ts_str)

        expr = ibis.literal(val)
        assert isinstance(expr, ir.TimestampScalar)

        expr = ibis.timestamp(ts_str)
        assert isinstance(expr, ir.TimestampScalar)

        self.assertRaises(ValueError, ibis.timestamp, '2015-01-01 00:71')
Esempio n. 20
0
def test_timestamp_scalar_in_filter(alltypes, translate):
    table = alltypes

    expr = table.filter(
        [
            table.timestamp_col
            < (ibis.timestamp('2010-01-01') + ibis.interval(weeks=3)),
            table.timestamp_col < (ibis.now() + ibis.interval(days=10)),
        ]
    ).count()
    expr.execute()
Esempio n. 21
0
    def test_timestamp_literals(self):
        ts_str = '2015-01-01 00:00:00'
        val = pd.Timestamp(ts_str)

        expr = ibis.literal(val)
        assert isinstance(expr, ir.TimestampScalar)

        expr = ibis.timestamp(ts_str)
        assert isinstance(expr, ir.TimestampScalar)

        self.assertRaises(ValueError, ibis.timestamp, '2015-01-01 00:71')
Esempio n. 22
0
    def test_mult_args(self):
        op = self._udf_registration(["int32", "double", "string", "boolean", "timestamp"], "int64", "mult_types")

        def _func(integer, double, string, boolean, timestamp):
            return op(integer, double, string, boolean, timestamp).to_expr()

        expr = _func(self.i32, self.d, self.s, self.b, self.t)
        assert issubclass(type(expr), ir.ArrayExpr)

        expr = _func(1, 1.0, "a", True, ibis.timestamp("1961-04-10"))
        assert issubclass(type(expr), ir.ScalarExpr)
Esempio n. 23
0
    def test_decimal_timestamp_builtins(self):
        table = self.con.table('tpch_lineitem')

        dc = table.l_quantity
        ts = table.l_receiptdate.cast('timestamp')

        exprs = [
            dc % 10,
            dc + 5,
            dc + dc,
            dc / 2,
            dc * 2,
            dc ** 2,
            dc.cast('double'),

            api.where(table.l_discount > 0,
                      dc * table.l_discount, api.NA),

            dc.fillna(0),

            ts < (ibis.now() + ibis.month(3)),
            ts < (ibis.timestamp('2005-01-01') + ibis.month(3)),

            # hashing
            dc.hash(),
            ts.hash(),

            # truncate
            ts.truncate('y'),
            ts.truncate('q'),
            ts.truncate('month'),
            ts.truncate('d'),
            ts.truncate('w'),
            ts.truncate('h'),
            ts.truncate('minute'),
        ]

        timestamp_fields = ['year', 'month', 'day', 'hour', 'minute',
                            'second', 'millisecond', 'microsecond',
                            'week']
        for field in timestamp_fields:
            if hasattr(ts, field):
                exprs.append(getattr(ts, field)())

            offset = getattr(ibis, field)(2)
            exprs.append(ts + offset)
            exprs.append(ts - offset)

        proj_exprs = [expr.name('e%d' % i)
                      for i, expr in enumerate(exprs)]

        projection = table[proj_exprs].limit(10)
        projection.execute()
Esempio n. 24
0
def test_mult_args(i32, d, s, b, t):
    func = _register_udf(
        ['int32', 'double', 'string', 'boolean', 'timestamp'],
        'int64',
        'mult_types',
    )

    expr = func(i32, d, s, b, t)
    assert issubclass(type(expr), ir.Column)

    expr = func(1, 1.0, 'a', True, ibis.timestamp('1961-04-10'))
    assert issubclass(type(expr), ir.Scalar)
Esempio n. 25
0
def test_strftime(con, pattern):
    value = ibis.timestamp('2015-09-01 14:48:05.359')
    raw_value = datetime(
        year=2015,
        month=9,
        day=1,
        hour=14,
        minute=48,
        second=5,
        microsecond=359000,
    )
    assert con.execute(value.strftime(pattern)) == raw_value.strftime(pattern)
Esempio n. 26
0
    def test_decimal_timestamp_builtins(self):
        table = self.con.table('tpch_lineitem')

        dc = table.l_quantity
        ts = table.l_receiptdate.cast('timestamp')

        exprs = [
            dc % 10,
            dc + 5,
            dc + dc,
            dc / 2,
            dc * 2,
            dc ** 2,
            dc.cast('double'),

            api.where(table.l_discount > 0,
                      dc * table.l_discount, api.NA),

            dc.fillna(0),

            ts < (ibis.now() + ibis.month(3)),
            ts < (ibis.timestamp('2005-01-01') + ibis.month(3)),

            # hashing
            dc.hash(),
            ts.hash(),

            # truncate
            ts.truncate('y'),
            ts.truncate('q'),
            ts.truncate('month'),
            ts.truncate('d'),
            ts.truncate('w'),
            ts.truncate('h'),
            ts.truncate('minute'),
        ]

        timestamp_fields = ['year', 'month', 'day', 'hour', 'minute',
                            'second', 'millisecond', 'microsecond',
                            'week']
        for field in timestamp_fields:
            if hasattr(ts, field):
                exprs.append(getattr(ts, field)())

            offset = getattr(ibis, field)(2)
            exprs.append(ts + offset)
            exprs.append(ts - offset)

        proj_exprs = [expr.name('e%d' % i)
                      for i, expr in enumerate(exprs)]

        projection = table[proj_exprs].limit(10)
        projection.execute()
Esempio n. 27
0
    def test_timestamp_literals(self):
        from pandas import Timestamp

        tv1 = '2015-01-01 12:34:56'
        ex1 = ("'2015-01-01 12:34:56'")

        cases = [
            (L(Timestamp(tv1)), ex1),
            (L(Timestamp(tv1).to_pydatetime()), ex1),
            (ibis.timestamp(tv1), ex1)
        ]
        self._check_expr_cases(cases)
Esempio n. 28
0
    def test_mult_args(self):
        op = self._udf_registration(['int32', 'double', 'string',
                                     'boolean', 'timestamp'],
                                    'int64', 'mult_types')

        def _func(integer, double, string, boolean, timestamp):
            return op(integer, double, string, boolean, timestamp).to_expr()

        expr = _func(self.i32, self.d, self.s, self.b, self.t)
        assert issubclass(type(expr), ir.ArrayExpr)

        expr = _func(1, 1.0, 'a', True, ibis.timestamp('1961-04-10'))
        assert issubclass(type(expr), ir.ScalarExpr)
Esempio n. 29
0
def test_to_timestamp(backend, con, unit):
    backend_unit = backend.returned_timestamp_unit
    factor = unit_factors[unit]

    ts = ibis.timestamp('2018-04-13 09:54:11.872832')
    pandas_ts = ibis.pandas.execute(ts).floor(unit).value

    # convert the now timestamp to the input unit being tested
    int_expr = ibis.literal(pandas_ts // factor)
    expr = int_expr.to_timestamp(unit)
    result = con.execute(expr)
    expected = pd.Timestamp(pandas_ts, unit='ns').floor(backend_unit)

    assert result == expected
Esempio n. 30
0
    def test_uda_primitive_output_types(self):
        types = [('boolean', True, self.b), ('int8', 1, self.i8),
                 ('int16', 1, self.i16), ('int32', 1, self.i32),
                 ('int64', 1, self.i64), ('float', 1.0, self.f),
                 ('double', 1.0, self.d), ('string', '1', self.s),
                 ('timestamp', ibis.timestamp('1961-04-10'), self.t)]
        for t, sv, av in types:
            func = self._register_uda([t], t, 'test')

            ibis_type = validate_type(t)

            expr1 = func(sv)
            expr2 = func(sv)
            assert isinstance(expr1, ibis_type.scalar_type())
            assert isinstance(expr2, ibis_type.scalar_type())
Esempio n. 31
0
def test_where_analyze_scalar_op(functional_alltypes):
    # root cause of #310
    table = functional_alltypes

    expr = table.filter([
        table.timestamp_col <
        (ibis.timestamp('2010-01-01') + ibis.interval(months=3)),
        table.timestamp_col < (ibis.now() + ibis.interval(days=10)),
    ]).count()

    result = Compiler.to_sql(expr)
    expected = """\
SELECT count(*) AS `count`
FROM functional_alltypes
WHERE (`timestamp_col` < date_add(cast({} as timestamp), INTERVAL 3 MONTH)) AND
      (`timestamp_col` < date_add(cast(now() as timestamp), INTERVAL 10 DAY))"""  # noqa: E501
    assert result == expected.format("'2010-01-01 00:00:00'")
Esempio n. 32
0
    def test_timestamp_builtins(self):
        i32 = ibis.literal(50000)
        i64 = ibis.literal(5 * 10 ** 8)

        stamp = ibis.timestamp("2009-05-17 12:34:56")

        timestamp_cases = [
            (i32.to_timestamp("s"), pd.to_datetime(50000, unit="s")),
            (i32.to_timestamp("ms"), pd.to_datetime(50000, unit="ms")),
            (i64.to_timestamp(), pd.to_datetime(5 * 10 ** 8, unit="s")),
            (stamp.truncate("y"), pd.Timestamp("2009-01-01")),
            (stamp.truncate("m"), pd.Timestamp("2009-05-01")),
            (stamp.truncate("d"), pd.Timestamp("2009-05-17")),
            (stamp.truncate("h"), pd.Timestamp("2009-05-17 12:00")),
            (stamp.truncate("minute"), pd.Timestamp("2009-05-17 12:34")),
        ]

        self.assert_cases_equality(timestamp_cases)
Esempio n. 33
0
    def test_where_analyze_scalar_op(self):
        # root cause of #310

        table = self.con.table('functional_alltypes')

        expr = (table.filter([
            table.timestamp_col <
            (ibis.timestamp('2010-01-01') + ibis.month(3)),
            table.timestamp_col < (ibis.now() + ibis.day(10))
        ]).count())

        result = to_sql(expr)
        expected = """\
SELECT count(*) AS `tmp`
FROM functional_alltypes
WHERE `timestamp_col` < months_add('2010-01-01 00:00:00', 3) AND
      `timestamp_col` < days_add(now(), 10)"""
        assert result == expected
Esempio n. 34
0
    def test_where_analyze_scalar_op(self):
        # root cause of #310

        table = self.con.table('functional_alltypes')

        expr = (table.filter([table.timestamp_col <
                             (ibis.timestamp('2010-01-01') + ibis.month(3)),
                             table.timestamp_col < (ibis.now() +
                                                    ibis.day(10))])
                .count())

        result = to_sql(expr)
        expected = """\
SELECT count(*) AS `tmp`
FROM functional_alltypes
WHERE `timestamp_col` < months_add('2010-01-01 00:00:00', 3) AND
      `timestamp_col` < days_add(now(), 10)"""
        assert result == expected
Esempio n. 35
0
    def test_timestamp_builtins(self):
        i32 = ibis.literal(50000)
        i64 = ibis.literal(5 * 10**8)

        stamp = ibis.timestamp('2009-05-17 12:34:56')

        timestamp_cases = [
            (i32.to_timestamp('s'), pd.to_datetime(50000, unit='s')),
            (i32.to_timestamp('ms'), pd.to_datetime(50000, unit='ms')),
            (i64.to_timestamp(), pd.to_datetime(5 * 10**8, unit='s')),
            (stamp.truncate('y'), pd.Timestamp('2009-01-01')),
            (stamp.truncate('m'), pd.Timestamp('2009-05-01')),
            (stamp.truncate('d'), pd.Timestamp('2009-05-17')),
            (stamp.truncate('h'), pd.Timestamp('2009-05-17 12:00')),
            (stamp.truncate('minute'), pd.Timestamp('2009-05-17 12:34'))
        ]

        self.assert_cases_equality(timestamp_cases)
Esempio n. 36
0
def test_to_timestamp(backend, con, unit):
    if unit not in backend.supported_to_timestamp_units:
        pytest.skip('Unit {!r} not supported by {} to_timestamp'.format(
            unit, backend))

    backend_unit = backend.returned_timestamp_unit
    factor = unit_factors[unit]

    ts = ibis.timestamp('2018-04-13 09:54:11.872832')
    pandas_ts = ibis.pandas.execute(ts).floor(unit).value

    # convert the now timestamp to the input unit being tested
    int_expr = ibis.literal(pandas_ts // factor)
    expr = int_expr.to_timestamp(unit)
    result = con.execute(expr)
    expected = pd.Timestamp(pandas_ts, unit='ns').floor(backend_unit)

    assert result == expected
Esempio n. 37
0
    def test_identity_primitive_types(self):
        cases = [
            ('boolean', True, self.alltypes.bool_col),
            ('int8', 5, self.alltypes.tinyint_col),
            ('int16', 2**10, self.alltypes.smallint_col),
            ('int32', 2**17, self.alltypes.int_col),
            ('int64', 2**33, self.alltypes.bigint_col),
            ('float', 3.14, self.alltypes.float_col),
            ('double', 3.14, self.alltypes.double_col),
            ('string', 'ibis', self.alltypes.string_col),
            ('timestamp', ibis.timestamp('1961-04-10'),
             self.alltypes.timestamp_col),
        ]

        for t, lit_val, array_val in cases:
            if not isinstance(lit_val, ir.Expr):
                lit_val = ibis.literal(lit_val)
            self._identity_func_testing(t, lit_val, array_val)
Esempio n. 38
0
    def test_identity_primitive_types(self):
        cases = [
            ('boolean', True, self.alltypes.bool_col),
            ('int8', 5, self.alltypes.tinyint_col),
            ('int16', 2**10, self.alltypes.smallint_col),
            ('int32', 2**17, self.alltypes.int_col),
            ('int64', 2**33, self.alltypes.bigint_col),
            ('float', 3.14, self.alltypes.float_col),
            ('double', 3.14, self.alltypes.double_col),
            ('string', 'ibis', self.alltypes.string_col),
            ('timestamp', ibis.timestamp('1961-04-10'),
             self.alltypes.timestamp_col),
        ]

        for t, lit_val, array_val in cases:
            if not isinstance(lit_val, ir.Expr):
                lit_val = ibis.literal(lit_val)
            self._identity_func_testing(t, lit_val, array_val)
Esempio n. 39
0
    def test_decimal_timestamp_builtins(self):
        table = self.con.table("tpch_lineitem")

        dc = table.l_quantity
        ts = table.l_receiptdate.cast("timestamp")

        exprs = [
            dc % 10,
            dc + 5,
            dc + dc,
            dc / 2,
            dc * 2,
            dc ** 2,
            dc.cast("double"),
            api.where(table.l_discount > 0, dc * table.l_discount, api.NA),
            dc.fillna(0),
            ts < (ibis.now() + ibis.month(3)),
            ts < (ibis.timestamp("2005-01-01") + ibis.month(3)),
            # hashing
            dc.hash(),
            ts.hash(),
            # truncate
            ts.truncate("y"),
            ts.truncate("q"),
            ts.truncate("month"),
            ts.truncate("d"),
            ts.truncate("w"),
            ts.truncate("h"),
            ts.truncate("minute"),
        ]

        timestamp_fields = ["year", "month", "day", "hour", "minute", "second", "millisecond", "microsecond", "week"]
        for field in timestamp_fields:
            if hasattr(ts, field):
                exprs.append(getattr(ts, field)())

            offset = getattr(ibis, field)(2)
            exprs.append(ts + offset)
            exprs.append(ts - offset)

        proj_exprs = [expr.name("e%d" % i) for i, expr in enumerate(exprs)]

        projection = table[proj_exprs].limit(10)
        projection.execute()
Esempio n. 40
0
def test_to_timestamp(backend, con, alltypes, df, unit):
    if unit not in backend.supported_to_timestamp_units:
        pytest.skip(
            'Unit {!r} not supported by {} to_timestamp'.format(unit, backend)
        )

    backend_unit = backend.returned_timestamp_unit
    factor = unit_factors[unit]

    ts = ibis.timestamp('2018-04-13 09:54:11.872832')
    pandas_ts = ibis.pandas.execute(ts).floor(unit).value

    # convert the now timestamp to the input unit being tested
    int_expr = ibis.literal(pandas_ts // factor)
    expr = int_expr.to_timestamp(unit)
    result = con.execute(expr)
    expected = pd.Timestamp(pandas_ts, unit='ns').floor(backend_unit)

    assert result == expected
Esempio n. 41
0
    def test_timestamp_builtins(self):
        i32 = L(50000)
        i64 = L(5 * 10 ** 8)

        stamp = ibis.timestamp('2009-05-17 12:34:56')

        timestamp_cases = [
            (i32.to_timestamp('s'), pd.to_datetime(50000, unit='s')),
            (i32.to_timestamp('ms'), pd.to_datetime(50000, unit='ms')),
            (i64.to_timestamp(), pd.to_datetime(5 * 10 ** 8, unit='s')),

            (stamp.truncate('y'), pd.Timestamp('2009-01-01')),
            (stamp.truncate('m'), pd.Timestamp('2009-05-01')),
            (stamp.truncate('d'), pd.Timestamp('2009-05-17')),
            (stamp.truncate('h'), pd.Timestamp('2009-05-17 12:00')),
            (stamp.truncate('minute'), pd.Timestamp('2009-05-17 12:34'))
        ]

        self.assert_cases_equality(timestamp_cases)
Esempio n. 42
0
    def test_uda_primitive_output_types(self):
        types = [
            ('boolean', True, self.b),
            ('int8', 1, self.i8),
            ('int16', 1, self.i16),
            ('int32', 1, self.i32),
            ('int64', 1, self.i64),
            ('float', 1.0, self.f),
            ('double', 1.0, self.d),
            ('string', '1', self.s),
            ('timestamp', ibis.timestamp('1961-04-10'), self.t)
        ]
        for t, sv, av in types:
            func = self._register_uda([t], t, 'test')

            ibis_type = validate_type(t)

            expr1 = func(sv)
            expr2 = func(sv)
            assert isinstance(expr1, ibis_type.scalar_type())
            assert isinstance(expr2, ibis_type.scalar_type())
Esempio n. 43
0
        (literal('2017-04-01'), date(2017, 4, 2)),
        (date(2017, 4, 2), literal('2017-04-01')),
        (literal('2017-04-01 01:02:33'), datetime(2017, 4, 1, 1, 3, 34)),
        (datetime(2017, 4, 1, 1, 3, 34), literal('2017-04-01 01:02:33')),
    ],
)
@pytest.mark.parametrize(
    'op',
    [
        operator.eq,
        operator.ne,
        operator.lt,
        operator.le,
        operator.gt,
        operator.ge,
        lambda left, right: ibis.timestamp('2017-04-01 00:02:34').between(
            left, right),
        lambda left, right: ibis.timestamp('2017-04-01').cast(dt.date).between(
            left, right),
    ],
)
def test_string_temporal_compare(op, left, right):
    result = op(left, right)
    assert result.type().equals(dt.boolean)


@pytest.mark.parametrize(
    ('value', 'type', 'expected_type_class'),
    [
        (2.21, 'decimal', dt.Decimal),
        (3.14, 'double', dt.Double),
        (4.2, 'int64', dt.Double),
Esempio n. 44
0
def test_timestamp_truncate(con, translate, unit, expected):
    stamp = ibis.timestamp('2009-05-17 12:34:56')
    expr = stamp.truncate(unit)
    assert con.execute(expr) == expected
Esempio n. 45
0
 def test_timestamp(self):
     func = self._udf_registration_single_input("timestamp", "timestamp", "test")
     expr = func(ibis.timestamp("1961-04-10"))
     assert type(expr) == ir.TimestampScalar
     expr = func(self.t)
     assert type(expr) == ir.TimestampArray
Esempio n. 46
0
def test_large_timestamp():
    expr = ibis.timestamp('4567-02-03')
    expected = datetime(year=4567, month=2, day=3)
    result = expr.op().value
    assert result == expected
Esempio n. 47
0
            lambda t, be: t.timestamp_col - pd.Timedelta(days=17),
            id='timestamp-subtract-interval',
        ),
        param(
            lambda t, be: t.timestamp_col.date() + ibis.interval(days=4),
            lambda t, be: t.timestamp_col.dt.floor('d') + pd.Timedelta(days=4),
            id='date-add-interval',
        ),
        param(
            lambda t, be: t.timestamp_col.date() - ibis.interval(days=14),
            lambda t, be: t.timestamp_col.dt.floor('d')
            - pd.Timedelta(days=14),
            id='date-subtract-interval',
        ),
        param(
            lambda t, be: t.timestamp_col - ibis.timestamp(timestamp_value),
            lambda t, be: pd.Series(
                t.timestamp_col.sub(timestamp_value).values.astype(
                    'timedelta64[{}]'.format(be.returned_timestamp_unit)
                )
            ),
            id='timestamp-subtract-timestamp',
        ),
        param(
            lambda t, be: t.timestamp_col.date() - ibis.date(date_value),
            lambda t, be: t.timestamp_col.dt.floor('d') - date_value,
            id='date-subtract-date',
        ),
    ],
)
@tu.skipif_unsupported
Esempio n. 48
0
def test_timestamp_with_timezone(tz):
    expr = ibis.timestamp('2017-01-01', timezone=tz)
    expected = pd.Timestamp('2017-01-01', tz=tz)
    result = expr.op().value
    assert expected == result
Esempio n. 49
0
def test_integer_timestamp_fails(value):
    with pytest.raises(
        TypeError, match=r"Use ibis\.literal\(-?\d+\)\.to_timestamp"
    ):
        ibis.timestamp(value)
Esempio n. 50
0
def test_timestamp_timezone_type(tz):
    expr = ibis.timestamp('2017-01-01', timezone=tz)
    expected = dt.Timestamp(timezone=tz)
    assert expected == expr.op().dtype
Esempio n. 51
0
def test_large_timestamp():
    expr = ibis.timestamp('4567-02-03')
    expected = datetime(year=4567, month=2, day=3)
    result = expr.op().value
    assert result == expected
Esempio n. 52
0
 def test_timestamp_wrapping(self):
     col = self.alltypes.timestamp_col
     literal = ibis.timestamp("1961-04-10")
     self._identity_func_testing("timestamp", literal, col)
Esempio n. 53
0
def uda_so(udfcon, test_data_dir):
    return pjoin(test_data_dir, 'udf/libudasample.so')


@pytest.mark.parametrize(
    ('typ', 'lit_val', 'col_name'),
    [
        ('boolean', True, 'bool_col'),
        ('int8', ibis.literal(5), 'tinyint_col'),
        ('int16', ibis.literal(2 ** 10), 'smallint_col'),
        ('int32', ibis.literal(2 ** 17), 'int_col'),
        ('int64', ibis.literal(2 ** 33), 'bigint_col'),
        ('float', ibis.literal(3.14), 'float_col'),
        ('double', ibis.literal(3.14), 'double_col'),
        ('string', ibis.literal('ibis'), 'string_col'),
        ('timestamp', ibis.timestamp('1961-04-10'), 'timestamp_col'),
    ],
)
def test_identity_primitive_types(
    udfcon, alltypes, test_data_db, udf_ll, typ, lit_val, col_name
):
    col_val = alltypes[col_name]
    identity_func_testing(udf_ll, udfcon, test_data_db, typ, lit_val, col_val)


def test_decimal(udfcon, test_data_db, udf_ll):
    col = udfcon.table('tpch_customer').c_acctbal
    literal = ibis.literal(1).cast('decimal(12,2)')
    name = '__tmp_udf_' + util.guid()

    func = udf_creation_to_op(
Esempio n. 54
0
        (date(2017, 4, 2), literal('2017-04-01')),
        (literal('2017-04-01 01:02:33'), datetime(2017, 4, 1, 1, 3, 34)),
        (datetime(2017, 4, 1, 1, 3, 34), literal('2017-04-01 01:02:33')),
    ],
)
@pytest.mark.parametrize(
    'op',
    [
        operator.eq,
        operator.ne,
        operator.lt,
        operator.le,
        operator.gt,
        operator.ge,
        lambda left, right: ibis.timestamp('2017-04-01 00:02:34').between(
            left, right
        ),
        lambda left, right: ibis.timestamp('2017-04-01')
        .cast(dt.date)
        .between(left, right),
    ],
)
def test_string_temporal_compare(op, left, right):
    result = op(left, right)
    assert result.type().equals(dt.boolean)


@pytest.mark.parametrize(
    ('value', 'type', 'expected_type_class'),
    [
        (2.21, 'decimal', dt.Decimal),
Esempio n. 55
0
def test_timestamp_with_timezone(tz):
    expr = ibis.timestamp('2017-01-01', timezone=tz)
    expected = pd.Timestamp('2017-01-01', tz=tz)
    result = expr.op().value
    assert expected == result
Esempio n. 56
0
def test_invalid_timestamp_literal():
    with pytest.raises(ValueError):
        ibis.timestamp('2015-01-01 00:71')
Esempio n. 57
0
def test_large_timestamp(client):
    huge_timestamp = datetime.datetime(year=4567, month=1, day=1)
    expr = ibis.timestamp('4567-01-01 00:00:00')
    result = client.execute(expr)
    assert result == huge_timestamp
Esempio n. 58
0
def test_timestamp_timezone_type(tz):
    expr = ibis.timestamp('2017-01-01', timezone=tz)
    expected = dt.Timestamp(timezone=tz)
    assert expected == expr.op().dtype