예제 #1
0
def test_literal_geospatial():
    # point
    point_0 = (0, 0)
    point = ibis.literal(point_0, type='point')
    assert ibis.mapd.compile(point) == "SELECT 'POINT(0 0)' AS tmp"

    # line
    line_0 = [point_0, point_0]
    line = ibis.literal(line_0, type='linestring')
    assert ibis.mapd.compile(line) == "SELECT 'LINESTRING(0 0, 0 0)' AS tmp"

    # polygon
    polygon_0 = [tuple(line_0), tuple(line_0)]
    polygon = ibis.literal(polygon_0, type='polygon')
    assert ibis.mapd.compile(polygon) == (
        "SELECT 'POLYGON((0 0, 0 0), (0 0, 0 0))' AS tmp"
    )

    # multipolygon
    mpolygon_0 = [tuple(polygon_0), tuple(polygon_0)]
    mpolygon = ibis.literal(mpolygon_0, type='multipolygon')
    assert ibis.mapd.compile(mpolygon) == (
        "SELECT 'MULTIPOLYGON(((0 0, 0 0), (0 0, 0 0)), "
        "((0 0, 0 0), (0 0, 0 0)))' AS tmp"
    )
예제 #2
0
def test_custom_type_binary_operations():
    class Foo(ir.ValueExpr):
        def __add__(self, other):
            op = self.op()
            return type(op)(op.value + other).to_expr()

        __radd__ = __add__

    class FooNode(ops.ValueOp):
        value = Arg(rlz.integer)

        def output_type(self):
            return functools.partial(Foo, dtype=dt.int64)

    left = ibis.literal(2)
    right = FooNode(3).to_expr()
    result = left + right
    assert isinstance(result, Foo)
    assert isinstance(result.op(), FooNode)

    left = FooNode(3).to_expr()
    right = ibis.literal(2)
    result = left + right
    assert isinstance(result, Foo)
    assert isinstance(result.op(), FooNode)
예제 #3
0
    def test_log_variants(self):
        opnames = ["ln", "log", "log2", "log10"]

        columns = ["a", "b", "c", "d", "e", "f"]

        for opname in opnames:

            def f(x):
                return getattr(x, opname)()

            for c in columns:
                result = f(self.table[c])
                assert isinstance(result, api.DoubleArray)

                # is this what we want?
                # assert result.get_name() == c

            assert isinstance(f(ibis.literal(5)), api.DoubleScalar)
            assert isinstance(f(ibis.literal(5.5)), api.DoubleScalar)

            klass = getattr(ops, opname.capitalize())
            with self.assertRaises(IbisTypeError):
                if opname == "log":
                    klass(self.table["g"], None).to_expr()
                else:
                    klass(self.table["g"]).to_expr()

            # boolean not implemented for these
            with self.assertRaises(IbisTypeError):
                f(self.table["h"])
예제 #4
0
def test_between(table):
    result = table.f.between(0, 1)

    assert isinstance(result, ir.BooleanColumn)
    assert isinstance(result.op(), ops.Between)

    # it works!
    result = table.g.between('a', 'f')
    assert isinstance(result, ir.BooleanColumn)

    result = ibis.literal(1).between(table.a, table.c)
    assert isinstance(result, ir.BooleanColumn)

    result = ibis.literal(7).between(5, 10)
    assert isinstance(result, ir.BooleanScalar)

    # Cases where between should immediately fail, e.g. incomparables
    with pytest.raises(TypeError):
        table.f.between('0', '1')

    with pytest.raises(TypeError):
        table.f.between(0, '1')

    with pytest.raises(TypeError):
        table.f.between('0', 1)
예제 #5
0
    def test_log_variants(self):
        opnames = ['ln', 'log', 'log2', 'log10']

        columns = ['a', 'b', 'c', 'd', 'e', 'f']

        for opname in opnames:
            def f(x):
                return getattr(x, opname)()

            for c in columns:
                result = f(self.table[c])
                assert isinstance(result, api.DoubleArray)

                # is this what we want?
                # assert result.get_name() == c

            assert isinstance(f(ibis.literal(5)), api.DoubleScalar)
            assert isinstance(f(ibis.literal(5.5)), api.DoubleScalar)

            klass = getattr(ops, opname.capitalize())
            with self.assertRaises(IbisTypeError):
                if opname == 'log':
                    klass(self.table['g'], None).to_expr()
                else:
                    klass(self.table['g']).to_expr()

            # boolean not implemented for these
            with self.assertRaises(IbisTypeError):
                f(self.table['h'])
예제 #6
0
    def test_boolean(self):
        val = True
        expr = ibis.literal(val)
        self._check_literal(expr, api.BooleanScalar, val)

        val = False
        expr = ibis.literal(val)
        self._check_literal(expr, api.BooleanScalar, val)
예제 #7
0
def test_array_concat_scalar(client, op):
    raw_left = [1, 2, 3]
    raw_right = [3, 4]
    left = ibis.literal(raw_left)
    right = ibis.literal(raw_right)
    expr = op(left, right)
    result = client.execute(expr)
    assert result == op(raw_left, raw_right)
예제 #8
0
def test_join(table):
    dash = literal('-')

    expr = dash.join([table.f.cast('string'), table.g])
    assert isinstance(expr, ir.StringColumn)

    expr = dash.join([literal('ab'), literal('cd')])
    assert isinstance(expr, ir.StringScalar)
예제 #9
0
def test_isnan_isinf_scalar(value):
    expr = ibis.literal(value).isnan()
    assert isinstance(expr, ir.BooleanScalar)
    assert isinstance(expr.op(), ops.IsNan)

    expr = ibis.literal(value).isinf()
    assert isinstance(expr, ir.BooleanScalar)
    assert isinstance(expr.op(), ops.IsInf)
예제 #10
0
 def test_literal_in_list(self):
     cases = [
         (ibis.literal(2).isin([self.table.a, self.table.b, self.table.c]),
          '2 IN (a, b, c)'),
         (ibis.literal(2).notin([self.table.a, self.table.b, self.table.c]),
          '2 NOT IN (a, b, c)')
     ]
     self._check_expr_cases(cases)
예제 #11
0
    def test_expr_list_no_table_refs(self):
        exlist = ibis.api.expr_list([ibis.literal(1).name('a'),
                                     ibis.now().name('b'),
                                     ibis.literal(2).log().name('c')])
        result = to_sql(exlist)
        expected = """\
SELECT 1 AS `a`, now() AS `b`, ln(2) AS `c`"""
        assert result == expected
예제 #12
0
    def test_join(self):
        dash = literal('-')

        expr = dash.join([self.table.f.cast('string'),
                          self.table.g])
        assert isinstance(expr, ir.StringArray)

        expr = dash.join([literal('ab'), literal('cd')])
        assert isinstance(expr, ir.StringScalar)
예제 #13
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)
예제 #14
0
    def test_execute_exprs_no_table_ref(self):
        cases = [(ibis.literal(1) + ibis.literal(2), 3)]

        for expr, expected in cases:
            result = self.con.execute(expr)
            assert result == expected

        # ExprList
        exlist = ibis.api.expr_list([ibis.literal(1).name("a"), ibis.now().name("b"), ibis.literal(2).log().name("c")])
        self.con.execute(exlist)
예제 #15
0
def test_concat():
    exprs = [ibis.literal(1).name('a'), ibis.literal(2).name('b')]
    exprs2 = [ibis.literal(3).name('c'), ibis.literal(4).name('d')]

    list1 = ibis.expr_list(exprs)
    list2 = ibis.expr_list(exprs2)

    result = list1.concat(list2)
    expected = ibis.expr_list(exprs + exprs2)
    assert_equal(result, expected)
예제 #16
0
    def test_concat(self):
        exprs = [ibis.literal(1).name("a"), ibis.literal(2).name("b")]

        exprs2 = [ibis.literal(3).name("c"), ibis.literal(4).name("d")]

        list1 = ibis.expr_list(exprs)
        list2 = ibis.expr_list(exprs2)

        result = list1.concat(list2)
        expected = ibis.expr_list(exprs + exprs2)
        assert_equal(result, expected)
예제 #17
0
def test_expr_list_no_table_refs():
    exlist = ibis.api.expr_list(
        [
            ibis.literal(1).name('a'),
            ibis.now().name('b'),
            ibis.literal(2).log().name('c'),
        ]
    )
    result = ibis.clickhouse.compile(exlist)
    expected = """\
SELECT 1 AS `a`, now() AS `b`, log(2) AS `c`"""
    assert result == expected
예제 #18
0
def test_group_concat(functional_alltypes):
    col = functional_alltypes.string_col

    expr = col.group_concat()
    assert isinstance(expr.op(), ops.GroupConcat)
    arg, sep, where = expr.op().args
    assert sep.equals(ibis.literal(','))
    assert where is None

    expr = col.group_concat('|')
    arg, sep, where = expr.op().args
    assert sep.equals(ibis.literal('|'))
    assert where is None
예제 #19
0
def test_non_inferrable_literal():
    expected_msg = (
        'The datatype of value .* cannot be inferred, try '
        'passing it explicitly with the `type` keyword.'
    )

    value = tuple(pointA)

    with pytest.raises(TypeError, match=expected_msg):
        ibis.literal(value)

    point = ibis.literal(value, type='point')
    assert point.type() == dt.point
예제 #20
0
 def test_decimal_builtins(self):
     d = ibis.literal(5.245)
     general_cases = [
         (ibis.literal(-5).abs(), 5),
         (d.cast("int32"), 5),
         (d.ceil(), 6),
         (d.isnull(), False),
         (d.floor(), 5),
         (d.notnull(), True),
         (d.round(), 5),
         (d.round(2), Decimal("5.25")),
         (d.sign(), 1),
     ]
     self.assert_cases_equality(general_cases)
예제 #21
0
    def test_int_builtins(self):
        i8 = ibis.literal(50)
        i32 = ibis.literal(50000)

        mod_cases = [(i8 % 5, 0), (i32 % 10, 0), (250 % i8, 0)]

        nullif_cases = [
            (5 / i8.nullif(0), 0.1),
            (5 / i8.nullif(i32), 0.1),
            (5 / i32.nullif(0), 0.0001),
            (i32.zeroifnull(), 50000),
        ]

        self.assert_cases_equality(mod_cases + nullif_cases)
예제 #22
0
def test_string_to_timestamp(client):
    timestamp = pd.Timestamp(
        datetime.datetime(year=2017, month=2, day=6), tz=pytz.timezone('UTC')
    )
    expr = ibis.literal('2017-02-06').to_timestamp('%F')
    result = client.execute(expr)
    assert result == timestamp

    timestamp_tz = pd.Timestamp(
        datetime.datetime(year=2017, month=2, day=6, hour=5),
        tz=pytz.timezone('UTC'),
    )
    expr_tz = ibis.literal('2017-02-06').to_timestamp('%F', 'America/New_York')
    result_tz = client.execute(expr_tz)
    assert result_tz == timestamp_tz
예제 #23
0
def test_boolean_logical_ops(table, operation):
    expr = table.a > 0

    result = operation(expr, table.h)
    assert isinstance(result, ir.BooleanColumn)

    result = operation(expr, True)
    refl_result = operation(True, expr)
    assert isinstance(result, ir.BooleanColumn)
    assert isinstance(refl_result, ir.BooleanColumn)

    true = ibis.literal(True)
    false = ibis.literal(False)

    result = operation(true, false)
    assert isinstance(result, ir.BooleanScalar)
예제 #24
0
    def test_substr(self):
        lit = literal('FoO')

        result = self.table.g.substr(2, 4)
        lit_result = lit.substr(0, 2)

        assert isinstance(result, ir.StringArray)
        assert isinstance(lit_result, ir.StringScalar)

        op = result.op()
        assert isinstance(op, ops.Substring)

        start, length = op.args[1:]

        assert start.equals(literal(2))
        assert length.equals(literal(4))
예제 #25
0
 def test_decimal_casts(self):
     cases = [
         (ibis.literal('9.9999999').cast('decimal(38,5)'),
          "CAST('9.9999999' AS decimal(38,5))"),
         (self.table.f.cast('decimal(12,2)'), "CAST(f AS decimal(12,2))")
     ]
     self._check_expr_cases(cases)
예제 #26
0
def test_literal_complex_types(value, expected_type, expected_class):
    expr = ibis.literal(value)
    expr_type = expr.type()
    assert expr_type.equals(dt.validate_type(expected_type))
    assert isinstance(expr, expected_class)
    assert isinstance(expr.op(), ops.Literal)
    assert expr.op().value is value
예제 #27
0
def test_integer_to_interval_date_failure(backend, con, alltypes, df, unit):
    interval = alltypes.int_col.to_interval(unit=unit)
    array = alltypes.date_string_col.split('/')
    month, day, year = array[0], array[1], array[2]
    date_col = ibis.literal('-').join(['20' + year, month, day]).cast('date')
    with pytest.raises(TypeError):
        date_col + interval
예제 #28
0
    def test_null(self):
        expr = ibis.literal(None)
        assert isinstance(expr, ir.NullScalar)
        assert isinstance(expr.op(), ir.NullLiteral)

        expr2 = ibis.null()
        assert_equal(expr, expr2)
예제 #29
0
def test_day_of_week_scalar(backend, con, date, expected_index, expected_day):
    expr = ibis.literal(date).cast(dt.date)
    result_index = con.execute(expr.day_of_week.index())
    assert result_index == expected_index

    result_day = con.execute(expr.day_of_week.full_name())
    assert result_day.lower() == expected_day.lower()
예제 #30
0
    def test_decimal_builtins_2(self):
        d = ibis.literal("5.245")
        dc = d.cast("decimal(12,5)")
        cases = [
            (dc % 5, Decimal("0.245")),
            (dc.fillna(0), Decimal("5.245")),
            (dc.exp(), 189.6158),
            (dc.log(), 1.65728),
            (dc.log2(), 2.39094),
            (dc.log10(), 0.71975),
            (dc.sqrt(), 2.29019),
            (dc.zeroifnull(), Decimal("5.245")),
            (-dc, Decimal("-5.245")),
        ]

        def approx_equal(a, b, eps):
            assert abs(a - b) < eps

        for expr, expected in cases:
            result = self.con.execute(expr)
            if isinstance(expected, Decimal):
                tol = Decimal("0.0001")
            else:
                tol = 0.0001
            approx_equal(result, expected, tol)
예제 #31
0
def test_literal(client):
    lit = ibis.literal(1)
    result = client.execute(lit)
    assert result == 1
예제 #32
0
def test_special_strings(con, alltypes, data, data_type):
    lit = ibis.literal(data, type=data_type).name('tmp')
    expr = alltypes[[alltypes.id, lit]].head(1)
    df = expr.execute()
    assert df['tmp'].iloc[0] == uuid.UUID(data)
예제 #33
0
 def test_implicit_typecasting(self):
     col = self.alltypes.tinyint_col
     literal = ibis.literal(1000)
     self._identity_func_testing('int32', literal, col)
예제 #34
0
def test_literal(client):
    assert client.execute(ibis.literal(1)) == 1
예제 #35
0
def test_float_format(client):
    expr = ibis.literal(1.0, type='float')
    assert client.compile(expr) == 'SELECT CAST(1.0 AS FLOAT) AS `tmp`'
예제 #36
0
 def test_double_wrapping(self):
     col = self.alltypes.double_col
     literal = ibis.literal(3.14)
     self._identity_func_testing('double', literal, col)
예제 #37
0
        param(
            lambda t: t.date_string_col[:],
            lambda t: t.date_string_col,
            id='expr_empty_slice',
        ),
        param(
            lambda t: t.date_string_col[t.date_string_col.length() - 2:t.
                                        date_string_col.length() - 1],
            lambda t: t.date_string_col.str[-2:-1],
            id='expr_slice_begin_end',
        ),
        param(
            lambda t: t.date_string_col.split('/'),
            lambda t: t.date_string_col.str.split('/'),
            id='split',
        ),
        param(
            lambda t: ibis.literal('-').join(['a', t.string_col, 'c']),
            lambda t: 'a-' + t.string_col + '-c',
            id='join',
        ),
    ],
)
@pytest.mark.xfail_unsupported
def test_string(backend, alltypes, df, result_func, expected_func):
    expr = result_func(alltypes)
    result = expr.execute()

    expected = backend.default_series_rename(expected_func(df))
    backend.assert_series_equal(result, expected)
예제 #38
0
""" Tests for geo spatial data types"""
import numpy as np
import pytest
from numpy import testing
from pytest import param

import ibis
from ibis.tests.backends import OmniSciDB, PostgreSQL

geopandas = pytest.importorskip('geopandas')
shapely = pytest.importorskip('shapely')
shapely_wkt = pytest.importorskip('shapely.wkt')

# geo literals declaration
point_0 = ibis.literal((0, 0), type='point').name('tmp')
point_0_4326 = ibis.literal((0, 0), type='point;4326').name('tmp')

point_geom_0 = ibis.literal((0, 0), type='point;4326:geometry').name('p')
point_geom_1 = ibis.literal((1, 1), type='point;4326:geometry').name('p')
point_geom_0_srid0 = ibis.literal((0, 0), type='point;0:geometry').name('p')
point_geom_1_srid0 = ibis.literal((1, 1), type='point;0:geometry').name('p')
point_geom_2 = ibis.literal((2, 2), type='point;4326:geometry').name('p')
point_geog_0 = ibis.literal((0, 0), type='point;4326:geography').name('p')
point_geog_1 = ibis.literal((1, 1), type='point;4326:geography').name('p')
point_geog_2 = ibis.literal((2, 2), type='point;4326:geography').name('p')
polygon_0 = ibis.literal(
    (
        ((1, 0), (0, 1), (-1, 0), (0, -1), (1, 0)),
        ((0.1, 0), (0, 0.1), (-0.1, 0), (0, -0.1), (0.1, 0)),
    ),
    type='polygon;4326:geometry',
예제 #39
0

@pytest.fixture
def sch_decimal():
    return ibis.schema([('index', 'int64'), ('n1', 'decimal'),
                        ('n2', 'decimal')])


@pytest.mark.parametrize(
    ('operand_fn', 'expected_operand_fn'),
    [
        param(lambda t: t.float_col, lambda t: t.float_col, id='float-column'),
        param(lambda t: t.double_col,
              lambda t: t.double_col,
              id='double-column'),
        param(lambda t: ibis.literal(1.3), lambda t: 1.3, id='float-literal'),
        param(lambda t: ibis.literal(np.nan),
              lambda t: np.nan,
              id='nan-literal'),
        param(lambda t: ibis.literal(np.inf),
              lambda t: np.inf,
              id='inf-literal'),
        param(
            lambda t: ibis.literal(-np.inf),
            lambda t: -np.inf,
            id='-inf-literal',
        ),
    ],
)
@pytest.mark.parametrize(
    ('expr_fn', 'expected_expr_fn'),
예제 #40
0
 def test_boolean_wrapping(self):
     col = self.alltypes.bool_col
     literal = ibis.literal(True)
     self._identity_func_testing('boolean', literal, col)
예제 #41
0
def test_datetime64_infer(client, unit):
    value = np.datetime64('2018-01-02', unit)
    expr = ibis.literal(value, type='timestamp')
    result = client.execute(expr)
    assert result == value
예제 #42
0
def test_timestamp_precedence():
    ts = ibis.literal(datetime.now())
    highest_type = rlz.highest_precedence_dtype([ibis.NA, ts])
    assert highest_type == dt.timestamp
예제 #43
0
 def test_float_wrapping(self):
     col = self.alltypes.float_col
     literal = ibis.literal(3.14)
     self._identity_func_testing('float', literal, col)
예제 #44
0
def test_literal_multi_geospatial_inferred(backend, con, shp, expected):
    result = str(con.compile(ibis.literal(shp)))
    result_expected = "SELECT {} AS tmp".format(expected[backend.name])
    assert result in result_expected
예제 #45
0
        ),
        (
            lambda t: t.int_col.cast(dt.timestamp),
            lambda at: sa.func.datetime(at.c.int_col, 'unixepoch'),
        ),
    ],
)
def test_timestamp_cast_noop(alltypes, func, translate, alltypes_sqla,
                             expected_func, sqla_compile):
    # See GH #592
    result = func(alltypes)
    expected = expected_func(alltypes_sqla)
    assert translate(result) == sqla_compile(expected)


TIMESTAMP_CONSTANT = ibis.literal('2015-09-01 14:48:05.359').cast('timestamp')


@pytest.mark.parametrize(
    ('expr', 'expected'),
    [
        (TIMESTAMP_CONSTANT.strftime('%Y%m%d'), '20150901'),
        (TIMESTAMP_CONSTANT.year(), 2015),
        (TIMESTAMP_CONSTANT.month(), 9),
        (TIMESTAMP_CONSTANT.day(), 1),
        (TIMESTAMP_CONSTANT.hour(), 14),
        (TIMESTAMP_CONSTANT.minute(), 48),
        (TIMESTAMP_CONSTANT.second(), 5),
        (TIMESTAMP_CONSTANT.millisecond(), 359),
    ],
)
예제 #46
0
 def test_int_wrapping(self):
     col = self.alltypes.int_col
     literal = ibis.literal(1000)
     self._identity_func_testing('int32', literal, col)
예제 #47
0
 def test_bigint_wrapping(self):
     col = self.alltypes.bigint_col
     literal = ibis.literal(1000).cast('int64')
     self._identity_func_testing('int64', literal, col)
예제 #48
0
def test_simple_case_scalar(client):
    x = ibis.literal(2)
    expr = x.case().when(2, x - 1).when(3, x + 1).when(4, x + 2).end()
    result = client.execute(expr)
    expected = np.int8(1)
    assert result == expected
예제 #49
0
def test_async(client):
    expr = ibis.literal(1)
    result = client.execute(expr, async=True)
    assert result.get_result() == 1
예제 #50
0
 def test_string_wrapping(self):
     col = self.alltypes.string_col
     literal = ibis.literal('ibis')
     self._identity_func_testing('string', literal, col)
예제 #51
0
            result_index,
            self.dtype,
            self.max_lookback,
            *args,
            **kwargs,
        )

        return result


@pytest.fixture(scope='session')
def sort_kind():
    return 'mergesort'


default = pytest.mark.parametrize('default', [ibis.NA, ibis.literal('a')])
row_offset = pytest.mark.parametrize('row_offset',
                                     list(map(ibis.literal, [-1, 1, 0])))
range_offset = pytest.mark.parametrize(
    'range_offset',
    [
        ibis.interval(days=1),
        2 * ibis.interval(days=1),
        -2 * ibis.interval(days=1),
    ],
)


@pytest.fixture
def row_window():
    return ibis.window(following=0, order_by='plain_int64')
예제 #52
0
 def test_tinyint_wrapping(self):
     col = self.alltypes.tinyint_col
     literal = ibis.literal(5)
     self._identity_func_testing('int8', literal, col)
예제 #53
0
    assert result == expected


@pytest.mark.parametrize('column', ['float64_with_zeros', 'int64_with_zeros'])
def test_null_if_zero(t, df, column):
    expr = t[column].nullifzero()
    result = expr.execute()
    expected = df[column].replace(0, np.nan)
    tm.assert_series_equal(result, expected)


@pytest.mark.parametrize(
    ('left', 'right', 'expected', 'compare'),
    [
        pytest.param(
            lambda t: ibis.literal(1),
            lambda t: ibis.literal(1),
            lambda df: np.nan,
            np.testing.assert_array_equal,  # treats NaNs as equal
            id='literal_literal_equal',
        ),
        pytest.param(
            lambda t: ibis.literal(1),
            lambda t: ibis.literal(2),
            lambda df: 1,
            np.testing.assert_equal,
            id='literal_literal_not_equal',
        ),
        pytest.param(
            lambda t: t.dup_strings,
            lambda t: ibis.literal('a'),
예제 #54
0
파일: test_rules.py 프로젝트: jelitox/ibis
@pytest.mark.parametrize(
    ('klass', 'value', 'expected'),
    [
        (ir.TableExpr, object, IbisTypeError),
        (ir.IntegerValue, 4, IbisTypeError),
    ],
)
def test_invalid_instance_of(klass, value, expected):
    with pytest.raises(expected):
        assert rlz.instance_of(klass, value)


@pytest.mark.parametrize(
    ('dtype', 'value', 'expected'),
    [
        pytest.param(dt.int8, 26, ibis.literal(26)),
        pytest.param(dt.int16, 26, ibis.literal(26)),
        pytest.param(dt.int32, 26, ibis.literal(26)),
        pytest.param(dt.int64, 26, ibis.literal(26)),
        pytest.param(dt.uint8, 26, ibis.literal(26)),
        pytest.param(dt.uint16, 26, ibis.literal(26)),
        pytest.param(dt.uint32, 26, ibis.literal(26)),
        pytest.param(dt.uint64, 26, ibis.literal(26)),
        pytest.param(dt.float32, 26, ibis.literal(26)),
        pytest.param(dt.float64, 26.4, ibis.literal(26.4)),
        pytest.param(dt.double, 26.3, ibis.literal(26.3)),
        pytest.param(dt.string, 'bar', ibis.literal('bar')),
        pytest.param(dt.Array(dt.float), [3.4, 5.6], ibis.literal([3.4, 5.6])),
        pytest.param(
            dt.Map(dt.string, dt.Array(dt.boolean)),
            {'a': [True, False], 'b': [True]},
예제 #55
0
def test_map_value_for_key_literal_broadcast(t):
    lookup_table = ibis.literal({'a': 1, 'b': 2, 'c': 3, 'd': 4})
    expr = lookup_table.get(t.dup_strings)
    result = expr.execute()
    expected = pd.Series([4, 1, 4], name='dup_strings')
    tm.assert_series_equal(result, expected)
예제 #56
0
def test_literal_execute(client):
    expected = '1234'
    expr = ibis.literal(expected)
    result = client.execute(expr)
    assert result == expected
예제 #57
0
파일: test_maps.py 프로젝트: jmileson/ibis
def test_map_values_scalar(client, t):
    expr = ibis.literal({'a': 10, 'b': 50, 'c': 20, 'd': 40})
    expr = expr.values()
    result = client.execute(expr)
    expected = np.array([10, 50, 20, 40])
    tm.assert_numpy_array_equal(result, expected)
예제 #58
0
def test_double_format(client):
    expr = ibis.literal(1.0)
    assert client.compile(expr) == 'SELECT 1.0d AS `tmp`'
예제 #59
0
파일: operations.py 프로젝트: vijoin/ibis
def _cross_join(translator, expr):
    args = expr.op().args
    left, right = args[:2]
    return translator.translate(left.join(right, ibis.literal(True)))
예제 #60
0
def test_endswith(table):
    assert isinstance(table.g.endswith('foo'), ir.BooleanColumn)
    assert isinstance(literal('bar').endswith('foo'), ir.BooleanScalar)