Python coalesce示例

示例#1

 def test_coalesce(self):
     cases = [
         (ibis.coalesce(5, None, 4), 5),
         (ibis.coalesce(ibis.NA, 4, ibis.NA), 4),
         (ibis.coalesce(ibis.NA, ibis.NA, 3.14), 3.14),
     ]
     self._check_e2e_cases(cases)

示例#2

文件： test_exprs.py 项目： thekingofhero/ibis

 def test_coalesce(self):
     t = self.table
     cases = [
         (ibis.coalesce(t.string_col, "foo"), "coalesce(`string_col`, 'foo')"),
         (ibis.coalesce(t.int_col, t.bigint_col), "coalesce(`int_col`, `bigint_col`)"),
     ]
     self._check_expr_cases(cases)

示例#3

文件： test_functions.py 项目： teamclairvoyant/ibis

 def test_coalesce(self):
     cases = [
         (ibis.coalesce(5, None, 4), 5),
         (ibis.coalesce(ibis.NA, 4, ibis.NA), 4),
         (ibis.coalesce(ibis.NA, ibis.NA, 3.14), 3.14),
     ]
     self._check_e2e_cases(cases)

示例#4

文件： test_functions.py 项目： teamclairvoyant/ibis

 def test_coalesce_all_na(self):
     NA = ibis.NA
     int8_na = ibis.NA.cast('int8')
     cases = [
         (ibis.coalesce(NA, NA), NA),
         (ibis.coalesce(NA, NA, NA.cast('double')), NA),
         (ibis.coalesce(int8_na, int8_na, int8_na), int8_na),
     ]
     self._check_e2e_cases(cases)

示例#5

文件： test_exprs.py 项目： nataliaking/ibis

 def test_coalesce(self):
     t = self.table
     cases = [
         (ibis.coalesce(t.string_col, 'foo'),
          "coalesce(string_col, 'foo')"),
         (ibis.coalesce(t.int_col, t.bigint_col),
          'coalesce(int_col, bigint_col)'),
     ]
     self._check_expr_cases(cases)

示例#6

 def test_coalesce_all_na(self):
     NA = ibis.NA
     int8_na = ibis.NA.cast('int8')
     cases = [
         (ibis.coalesce(NA, NA), NA),
         (ibis.coalesce(NA, NA, NA.cast('double')), NA),
         (ibis.coalesce(int8_na, int8_na, int8_na), int8_na),
     ]
     self._check_e2e_cases(cases)

示例#7

 def test_coalesce(self):
     t = self.table
     cases = [
         (ibis.coalesce(t.string_col, 'foo'),
          "coalesce(`string_col`, 'foo')"),
         (ibis.coalesce(t.int_col, t.bigint_col),
          'coalesce(`int_col`, `bigint_col`)'),
     ]
     self._check_expr_cases(cases)

示例#8

文件： test_sql_builtins.py 项目： Vicky-leilei/ibis

    def test_coalesce_instance_method(self):
        v7 = self.table.v7
        v5 = self.table.v5.cast('string')
        v8 = self.table.v8.cast('string')

        result = v7.coalesce(v5, v8, 'foo')
        expected = ibis.coalesce(v7, v5, v8, 'foo')
        assert_equal(result, expected)

示例#9

    def test_coalesce_instance_method(self):
        v7 = self.table.v7
        v5 = self.table.v5.cast('string')
        v8 = self.table.v8.cast('string')

        result = v7.coalesce(v5, v8, 'foo')
        expected = ibis.coalesce(v7, v5, v8, 'foo')
        assert_equal(result, expected)

示例#10

文件： test_sqlalchemy.py 项目： thekingofhero/ibis

    def test_coalesce(self):
        sat = self.sa_alltypes
        sd = sat.c.double_col
        sf = sat.c.float_col

        d = self.alltypes.double_col
        f = self.alltypes.float_col
        null = sa.null()

        v1 = ibis.NA
        v2 = (d > 30).ifelse(d, ibis.NA)
        v3 = f

        cases = [(ibis.coalesce(v2, v1, v3), sa.func.coalesce(sa.case([(sd > L(30), sd)], else_=null), null, sf))]
        self._check_expr_cases(cases)

示例#11

    def test_coalesce(self):
        sat = self.sa_alltypes
        sd = sat.c.double_col
        sf = sat.c.float_col

        d = self.alltypes.double_col
        f = self.alltypes.float_col
        null = sa.null()

        v1 = ibis.NA
        v2 = (d > 30).ifelse(d, ibis.NA)
        v3 = f

        cases = [(ibis.coalesce(v2, v1, v3),
                  sa.func.coalesce(sa.case([(sd > L(30), sd)], else_=null),
                                   null, sf))]
        self._check_expr_cases(cases)

示例#12

def test_coalesce(sa_functional_alltypes, functional_alltypes):
    sat = sa_functional_alltypes
    sd = sat.c.double_col
    sf = sat.c.float_col

    d = functional_alltypes.double_col
    f = functional_alltypes.float_col
    null = sa.null()

    v1 = ibis.NA
    v2 = (d > 30).ifelse(d, ibis.NA)
    v3 = f

    expr = ibis.coalesce(v2, v1, v3)
    expected = sa.select([
        sa.func.coalesce(
            sa.case([(sd > L(30), sd)], else_=null),
            null,
            sf,
        ).label("tmp")
    ])
    _check(expr, expected)

示例#13

文件： test_functions.py 项目： cloudera/ibis

    ('expr', 'expected'),
    [
        (L(None).isnull(), True),
        (L(1).isnull(), False),
        (L(None).notnull(), False),
        (L(1).notnull(), True),
    ],
)
def test_isnull_notnull(con, expr, expected):
    assert con.execute(expr) == expected


@pytest.mark.parametrize(
    ('expr', 'expected'),
    [
        (ibis.coalesce(5, None, 4), 5),
        (ibis.coalesce(ibis.NA, 4, ibis.NA), 4),
        (ibis.coalesce(ibis.NA, ibis.NA, 3.14), 3.14),
    ],
)
def test_coalesce(con, expr, expected):
    assert con.execute(expr) == expected


@pytest.mark.parametrize(
    ('expr', 'expected'),
    [
        (ibis.NA.fillna(5), 5),
        (L(5).fillna(10), 5),
        (L(5).nullif(5), None),
        (L(10).nullif(5), 10),

示例#14

文件： test_functions.py 项目： djKooks/ibis

    else:
        assert result == expected


@pytest.mark.parametrize(('expr', 'expected'), [
    (L(None).isnull(), True),
    (L(1).isnull(), False),
    (L(None).notnull(), False),
    (L(1).notnull(), True),
])
def test_isnull_notnull(con, expr, expected):
    assert con.execute(expr) == expected


@pytest.mark.parametrize(('expr', 'expected'), [
    (ibis.coalesce(5, None, 4), 5),
    (ibis.coalesce(ibis.NA, 4, ibis.NA), 4),
    (ibis.coalesce(ibis.NA, ibis.NA, 3.14), 3.14),
])
def test_coalesce(con, expr, expected):
    assert con.execute(expr) == expected


# TODO: clickhouse cannot cast NULL to other types
# @pytest.mark.parametrize(
#     ('expr', 'expected'),
#     [
#         (ibis.coalesce(ibis.NA, ibis.NA), None),
#         (ibis.coalesce(ibis.NA, ibis.NA, ibis.NA.cast('double')), None),
#         (
#             ibis.coalesce(

示例#15

文件： test_coalesce_greater_least.py 项目： jelitox/ibis

import ibis

from .conftest import translate


@pytest.fixture(scope="module")
def table(mockcon):
    return mockcon.table("functional_alltypes")


@pytest.mark.parametrize(
    ("expr_fn", "expected"),
    [
        pytest.param(
            lambda t: ibis.coalesce(t.string_col, 'foo'),
            "coalesce(`string_col`, 'foo')",
            id="coalesce_scalar",
        ),
        pytest.param(
            lambda t: ibis.coalesce(t.int_col, t.bigint_col),
            'coalesce(`int_col`, `bigint_col`)',
            id="coalesce_columns",
        ),
        pytest.param(
            lambda t: ibis.greatest(t.string_col, 'foo'),
            "greatest(`string_col`, 'foo')",
            id="greatest_scalar",
        ),
        pytest.param(
            lambda t: ibis.greatest(t.int_col, t.bigint_col),

示例#16

文件： test_functions.py 项目： jelitox/ibis

    ('expr', 'expected'),
    [
        param(ibis.NA.fillna(5), 5, id='filled'),
        param(L(5).fillna(10), 5, id='not_filled'),
        param(L(5).nullif(5), None, id='nullif_null'),
        param(L(10).nullif(5), 10, id='nullif_not_null'),
    ],
)
def test_fillna_nullif(con, expr, expected):
    assert con.execute(expr) == expected


@pytest.mark.parametrize(
    ('expr', 'expected'),
    [
        param(ibis.coalesce(5, None, 4), 5, id='first'),
        param(ibis.coalesce(ibis.NA, 4, ibis.NA), 4, id='second'),
        param(ibis.coalesce(ibis.NA, ibis.NA, 3.14), 3.14, id='third'),
    ],
)
def test_coalesce(con, expr, expected):
    assert con.execute(expr) == expected


@pytest.mark.parametrize(
    ('expr', 'expected'),
    [
        param(ibis.coalesce(ibis.NA, ibis.NA), None, id='all_null'),
        param(
            ibis.coalesce(ibis.NA, ibis.NA, ibis.NA.cast('double')),
            None,

示例#17

def test_coalesce_all_na_double(con):
    expr = ibis.coalesce(ibis.NA, ibis.NA, ibis.NA.cast('double'))
    assert np.isnan(con.execute(expr))

示例#18

    ('expr', 'expected'),
    [
        (ibis.NA.fillna(5), 5),
        (L(5).fillna(10), 5),
        (L(5).nullif(5), None),
        (L(10).nullif(5), 10),
    ]
)
def test_fillna_nullif(con, expr, expected):
    assert con.execute(expr) == expected


@pytest.mark.parametrize(
    ('expr', 'expected'),
    [
        (ibis.coalesce(5, None, 4), 5),
        (ibis.coalesce(ibis.NA, 4, ibis.NA), 4),
        (ibis.coalesce(ibis.NA, ibis.NA, 3.14), 3.14),
    ]
)
def test_coalesce(con, expr, expected):
    assert con.execute(expr) == expected


@pytest.mark.parametrize(
    ('expr', 'expected'),
    [
        (ibis.coalesce(ibis.NA, ibis.NA), None),
        (ibis.coalesce(ibis.NA, ibis.NA, ibis.NA.cast('double')), None),
        (
            ibis.coalesce(

示例#19

    assert t.a.sum()._repr_html_() is None

    interactive = ibis.options.interactive
    ibis.options.interactive = True
    try:
        assert 'table' in t._repr_html_()
        assert 'table' in t.a._repr_html_()
        assert t.a.sum()._repr_html_() is None
    finally:
        ibis.options.interactive = interactive


@pytest.mark.parametrize(
    ("expr", "expected_type"),
    [
        (ibis.coalesce(ibis.NA, 1), dt.int8),
        (ibis.coalesce(1, ibis.NA), dt.int8),
        (ibis.coalesce(ibis.NA, 1000), dt.int16),
        (ibis.coalesce(ibis.NA), dt.null),
        (ibis.coalesce(ibis.NA, ibis.NA), dt.null),
        (
            ibis.coalesce(ibis.NA, ibis.NA.cast("array<string>")),
            dt.Array(dt.string),
        ),
    ],
)
def test_coalesce_type_inference_with_nulls(expr, expected_type):
    assert expr.type() == expected_type


def test_literal_hash():