ClickHouse

1
#include <Functions/IFunction.h>
2
#include <Functions/FunctionHelpers.h>
3
#include <Functions/FunctionFactory.h>
4
#include <DataTypes/DataTypesNumber.h>
5
#include <Core/ColumnNumbers.h>
6
#include <Columns/ColumnNullable.h>
7
#include <Columns/ColumnLowCardinality.h>
8
#include <Columns/ColumnVariant.h>
9

10

11
namespace DB
12
{
13
namespace
14
{
15

16
/// Implements the function isNull which returns true if a value
17
/// is null, false otherwise.
18
class FunctionIsNull : public IFunction
19
{
20
public:
21
    static constexpr auto name = "isNull";
22

23
    static FunctionPtr create(ContextPtr)
24
    {
25
        return std::make_shared<FunctionIsNull>();
26
    }
27

28
    std::string getName() const override
29
    {
30
        return name;
31
    }
32

33
    size_t getNumberOfArguments() const override { return 1; }
34
    bool useDefaultImplementationForNulls() const override { return false; }
35
    bool useDefaultImplementationForLowCardinalityColumns() const override { return false; }
36
    bool useDefaultImplementationForConstants() const override { return true; }
37
    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; }
38
    ColumnNumbers getArgumentsThatDontImplyNullableReturnType(size_t /*number_of_arguments*/) const override { return {0}; }
39

40
    DataTypePtr getReturnTypeImpl(const DataTypes &) const override
41
    {
42
        return std::make_shared<DataTypeUInt8>();
43
    }
44

45
    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t) const override
46
    {
47
        const ColumnWithTypeAndName & elem = arguments[0];
48

49
        if (isVariant(elem.type))
50
        {
51
            const auto & discriminators = checkAndGetColumn<ColumnVariant>(*elem.column)->getLocalDiscriminators();
52
            auto res = DataTypeUInt8().createColumn();
53
            auto & data = typeid_cast<ColumnUInt8 &>(*res).getData();
54
            data.reserve(discriminators.size());
55
            for (auto discr : discriminators)
56
                data.push_back(discr == ColumnVariant::NULL_DISCRIMINATOR);
57
            return res;
58
        }
59

60
        if (elem.type->isLowCardinalityNullable())
61
        {
62
            const auto * low_cardinality_column = checkAndGetColumn<ColumnLowCardinality>(*elem.column);
63
            size_t null_index = low_cardinality_column->getDictionary().getNullValueIndex();
64
            auto res = DataTypeUInt8().createColumn();
65
            auto & data = typeid_cast<ColumnUInt8 &>(*res).getData();
66
            data.reserve(low_cardinality_column->size());
67
            for (size_t i = 0; i != low_cardinality_column->size(); ++i)
68
                data.push_back(low_cardinality_column->getIndexAt(i) == null_index);
69
            return res;
70
        }
71

72
        if (const auto * nullable = checkAndGetColumn<ColumnNullable>(*elem.column))
73
        {
74
            /// Merely return the embedded null map.
75
            return nullable->getNullMapColumnPtr();
76
        }
77
        else
78
        {
79
            /// Since no element is nullable, return a zero-constant column representing
80
            /// a zero-filled null map.
81
            return DataTypeUInt8().createColumnConst(elem.column->size(), 0u);
82
        }
83
    }
84
};
85

86
}
87

88
REGISTER_FUNCTION(IsNull)
89
{
90
    factory.registerFunction<FunctionIsNull>({}, FunctionFactory::CaseInsensitive);
91
}
92

93
}
94