ClickHouse

1
#include <DataTypes/DataTypeString.h>
2
#include <DataTypes/DataTypesNumber.h>
3
#include <Columns/ColumnString.h>
4
#include <Columns/ColumnsNumber.h>
5
#include <Functions/FunctionFactory.h>
6
#include <Parsers/queryNormalization.h>
7

8

9
/** The function returns 64bit hash value that is identical for similar queries.
10
  * See also 'normalizeQuery'. This function is only slightly more efficient.
11
  */
12

13
namespace DB
14
{
15
namespace ErrorCodes
16
{
17
    extern const int ILLEGAL_COLUMN;
18
    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
19
}
20

21
namespace
22
{
23

24
template <bool keep_names>
25
struct Impl
26
{
27
    static void vector(
28
        const ColumnString::Chars & data,
29
        const ColumnString::Offsets & offsets,
30
        PaddedPODArray<UInt64> & res_data)
31
    {
32
        size_t size = offsets.size();
33
        res_data.resize(size);
34

35
        ColumnString::Offset prev_src_offset = 0;
36
        for (size_t i = 0; i < size; ++i)
37
        {
38
            ColumnString::Offset curr_src_offset = offsets[i];
39
            res_data[i] = normalizedQueryHash(
40
                reinterpret_cast<const char *>(&data[prev_src_offset]),
41
                reinterpret_cast<const char *>(&data[curr_src_offset - 1]),
42
                keep_names);
43
            prev_src_offset = offsets[i];
44
        }
45
    }
46
};
47

48
template <bool keep_names>
49
class FunctionNormalizedQueryHash : public IFunction
50
{
51
public:
52
    static constexpr auto name = keep_names ? "normalizedQueryHashKeepNames" : "normalizedQueryHash";
53
    static FunctionPtr create(ContextPtr)
54
    {
55
        return std::make_shared<FunctionNormalizedQueryHash>();
56
    }
57

58
    String getName() const override
59
    {
60
        return name;
61
    }
62

63
    size_t getNumberOfArguments() const override
64
    {
65
        return 1;
66
    }
67

68
    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
69
    {
70
        if (!isString(arguments[0]))
71
            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument of function {}", arguments[0]->getName(), getName());
72

73
        return std::make_shared<DataTypeUInt64>();
74
    }
75

76
    bool useDefaultImplementationForConstants() const override { return true; }
77

78
    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
79

80
    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override
81
    {
82
        const ColumnPtr column = arguments[0].column;
83
        if (const ColumnString * col = checkAndGetColumn<ColumnString>(column.get()))
84
        {
85
            auto col_res = ColumnUInt64::create();
86
            typename ColumnUInt64::Container & vec_res = col_res->getData();
87
            vec_res.resize(col->size());
88
            Impl<keep_names>::vector(col->getChars(), col->getOffsets(), vec_res);
89
            return col_res;
90
        }
91
        else
92
            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of argument of function {}",
93
                arguments[0].column->getName(), getName());
94
    }
95
};
96

97
}
98

99
REGISTER_FUNCTION(NormalizedQueryHash)
100
{
101
    factory.registerFunction<FunctionNormalizedQueryHash<true>>();
102
    factory.registerFunction<FunctionNormalizedQueryHash<false>>();
103
}
104

105
}
106