aboutsummaryrefslogtreecommitdiffstats
path: root/yql/essentials/minikql/comp_nodes/mkql_match_recognize_measure_arg.cpp
blob: 9a152dfceca664ea735952bc09700e4e273253a2 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#include "mkql_match_recognize_measure_arg.h"

namespace NKikimr::NMiniKQL::NMatchRecognize {

TRowForMeasureValue::TRowForMeasureValue(
    TMemoryUsageInfo* memInfo,
    NUdf::TUnboxedValue inputRow,
    ui64 rowIndex,
    const TMeasureInputColumnOrder& columnOrder,
    const NUdf::TUnboxedValue& matchedVars,
    const TUnboxedValueVector& varNames,
    ui64 matchNumber)
: TComputationValue<TRowForMeasureValue>(memInfo)
, InputRow(inputRow)
, RowIndex(rowIndex)
, ColumnOrder(columnOrder)
, MatchedVars(matchedVars)
, VarNames(varNames)
, MatchNumber(matchNumber)
{}

NUdf::TUnboxedValue TRowForMeasureValue::GetElement(ui32 index) const {
    switch(ColumnOrder[index].first) {
        case NYql::NMatchRecognize::EMeasureInputDataSpecialColumns::Classifier: {
            auto varIterator = MatchedVars.GetListIterator();
            MKQL_ENSURE(varIterator, "Internal logic error");
            NUdf::TUnboxedValue var;
            size_t varIndex = 0;
            while(varIterator.Next(var)) {
                auto rangeIterator = var.GetListIterator();
                MKQL_ENSURE(varIterator, "Internal logic error");
                NUdf::TUnboxedValue range;
                while(rangeIterator.Next(range)) {
                    const auto from = range.GetElement(0).Get<ui64>();
                    const auto to = range.GetElement(1).Get<ui64>();
                    if (RowIndex >= from and RowIndex <= to) {
                        return VarNames[varIndex];
                    }
                }
                ++varIndex;
            }
            MKQL_ENSURE(MatchedVars.GetListLength() == varIndex, "Internal logic error");
            return MakeString("");
        }
        case NYql::NMatchRecognize::EMeasureInputDataSpecialColumns::MatchNumber:
            return NUdf::TUnboxedValuePod(MatchNumber);
        case NYql::NMatchRecognize::EMeasureInputDataSpecialColumns::Last: //Last corresponds to columns from the input table row
            return InputRow.GetElement(ColumnOrder[index].second);
    }
}

TMeasureInputDataValue::TMeasureInputDataValue(
    TMemoryUsageInfo* memInfo,
    const NUdf::TUnboxedValue& inputData,
    const TMeasureInputColumnOrder& columnOrder,
    const NUdf::TUnboxedValue& matchedVars,
    const TUnboxedValueVector& varNames,
    ui64 matchNumber)
: TComputationValue<TMeasureInputDataValue>(memInfo)
, InputData(inputData)
, ColumnOrder(columnOrder)
, MatchedVars(matchedVars)
, VarNames(varNames)
, MatchNumber(matchNumber)
{}

bool TMeasureInputDataValue::HasFastListLength() const {
    return true;
}

ui64 TMeasureInputDataValue::GetListLength() const {
    return GetDictLength();
}

ui64 TMeasureInputDataValue::GetEstimatedListLength() const {
    return GetListLength();
}

NUdf::TUnboxedValue TMeasureInputDataValue::GetListIterator() const {
    return GetPayloadsIterator();
}

bool TMeasureInputDataValue::HasListItems() const {
    return HasDictItems();
}

NUdf::IBoxedValuePtr TMeasureInputDataValue::ToIndexDictImpl(const NUdf::IValueBuilder& builder) const {
    Y_UNUSED(builder);
    return const_cast<TMeasureInputDataValue*>(this);
}

ui64 TMeasureInputDataValue::GetDictLength() const {
    return InputData.GetDictLength();
}

NUdf::TUnboxedValue TMeasureInputDataValue::GetDictIterator() const {
    return InputData.GetDictIterator();
}

NUdf::TUnboxedValue TMeasureInputDataValue::GetKeysIterator() const {
    return InputData.GetKeysIterator();
}

NUdf::TUnboxedValue TMeasureInputDataValue::GetPayloadsIterator() const {
    return InputData.GetPayloadsIterator();
}

bool TMeasureInputDataValue::Contains(const NUdf::TUnboxedValuePod& key) const {
    return InputData.Contains(key);
}

NUdf::TUnboxedValue TMeasureInputDataValue::Lookup(const NUdf::TUnboxedValuePod& key) const {
    return NUdf::TUnboxedValuePod{new TRowForMeasureValue(
        GetMemInfo(),
        InputData.Lookup(key),
        key.Get<ui64>(),
        ColumnOrder,
        MatchedVars,
        VarNames,
        MatchNumber
    )};
}

bool TMeasureInputDataValue::HasDictItems() const {
    return InputData.HasDictItems();
}

} // namespace NKikimr::NMiniKQL::NMatchRecognize