ClickHouse

1
#include <Functions/FunctionsStringSearchToString.h>
2
#include <Functions/FunctionFactory.h>
3
#include <Functions/Regexps.h>
4
#include <Common/OptimizedRegularExpression.h>
5

6

7
namespace DB
8
{
9
namespace
10
{
11

12
struct ExtractImpl
13
{
14
    static void vector(
15
        const ColumnString::Chars & data,
16
        const ColumnString::Offsets & offsets,
17
        const std::string & pattern,
18
        ColumnString::Chars & res_data,
19
        ColumnString::Offsets & res_offsets)
20
    {
21
        res_data.reserve(data.size() / 5);
22
        res_offsets.resize(offsets.size());
23

24
        const OptimizedRegularExpression regexp = Regexps::createRegexp<false, false, false>(pattern);
25

26
        unsigned capture = regexp.getNumberOfSubpatterns() > 0 ? 1 : 0;
27
        OptimizedRegularExpression::MatchVec matches;
28
        matches.reserve(capture + 1);
29
        size_t prev_offset = 0;
30
        size_t res_offset = 0;
31

32
        for (size_t i = 0; i < offsets.size(); ++i)
33
        {
34
            size_t cur_offset = offsets[i];
35

36
            unsigned count
37
                = regexp.match(reinterpret_cast<const char *>(&data[prev_offset]), cur_offset - prev_offset - 1, matches, capture + 1);
38
            if (count > capture && matches[capture].offset != std::string::npos)
39
            {
40
                const auto & match = matches[capture];
41
                res_data.resize(res_offset + match.length + 1);
42
                memcpySmallAllowReadWriteOverflow15(&res_data[res_offset], &data[prev_offset + match.offset], match.length);
43
                res_offset += match.length;
44
            }
45
            else
46
            {
47
                res_data.resize(res_offset + 1);
48
            }
49

50
            res_data[res_offset] = 0;
51
            ++res_offset;
52
            res_offsets[i] = res_offset;
53

54
            prev_offset = cur_offset;
55
        }
56
    }
57
};
58

59
struct NameExtract
60
{
61
    static constexpr auto name = "extract";
62
};
63

64
using FunctionExtract = FunctionsStringSearchToString<ExtractImpl, NameExtract>;
65

66
}
67

68
REGISTER_FUNCTION(Extract)
69
{
70
    factory.registerFunction<FunctionExtract>();
71
}
72

73
}
74