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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionBinaryArithmetic.h>
#include <base/hex.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
extern const int LOGICAL_ERROR;
}
namespace
{
template <typename A, typename B>
struct BitShiftRightImpl
{
using ResultType = typename NumberTraits::ResultOfBit<A, B>::Type;
static const constexpr bool allow_fixed_string = false;
static const constexpr bool allow_string_integer = true;
template <typename Result = ResultType>
static inline NO_SANITIZE_UNDEFINED Result apply(A a [[maybe_unused]], B b [[maybe_unused]])
{
if constexpr (is_big_int_v<B>)
throw Exception(ErrorCodes::NOT_IMPLEMENTED, "BitShiftRight is not implemented for big integers as second argument");
else if constexpr (is_big_int_v<A>)
return static_cast<Result>(a) >> static_cast<UInt32>(b);
else
return static_cast<Result>(a) >> static_cast<Result>(b);
}
static inline NO_SANITIZE_UNDEFINED void bitShiftRightForBytes(const UInt8 * op_pointer, const UInt8 * begin, UInt8 * out, const size_t shift_right_bits)
{
while (op_pointer > begin)
{
op_pointer--;
out--;
*out = *op_pointer >> shift_right_bits;
if (op_pointer - 1 >= begin)
{
/// The right b bit of the left byte is moved to the left b bit of this byte
*out = static_cast<UInt8>(static_cast<UInt8>(*(op_pointer - 1) << (8 - shift_right_bits)) | *out);
}
}
}
/// For String
static ALWAYS_INLINE NO_SANITIZE_UNDEFINED void apply(const UInt8 * pos [[maybe_unused]], const UInt8 * end [[maybe_unused]], const B & b [[maybe_unused]], ColumnString::Chars & out_vec, ColumnString::Offsets & out_offsets)
{
if constexpr (is_big_int_v<B>)
throw Exception(ErrorCodes::NOT_IMPLEMENTED, "BitShiftRight is not implemented for big integers as second argument");
else
{
UInt8 word_size = 8;
/// To prevent overflow
if (static_cast<double>(b) >= (static_cast<double>(end - pos) * word_size) || b < 0)
{
/// insert default value
out_vec.push_back(0);
out_offsets.push_back(out_offsets.back() + 1);
return;
}
size_t shift_right_bytes = b / word_size;
size_t shift_right_bits = b % word_size;
const UInt8 * begin = pos;
const UInt8 * shift_right_end = end - shift_right_bytes;
const size_t old_size = out_vec.size();
size_t length = shift_right_end - begin;
const size_t new_size = old_size + length + 1;
out_vec.resize(new_size);
out_vec[old_size + length] = 0;
/// We start from the byte on the right and shift right shift_right_bits bit by byte
UInt8 * op_pointer = const_cast<UInt8 *>(shift_right_end);
UInt8 * out = out_vec.data() + old_size + length;
bitShiftRightForBytes(op_pointer, begin, out, shift_right_bits);
out_offsets.push_back(new_size);
}
}
/// For FixedString
static ALWAYS_INLINE NO_SANITIZE_UNDEFINED void apply(const UInt8 * pos [[maybe_unused]], const UInt8 * end [[maybe_unused]], const B & b [[maybe_unused]], ColumnFixedString::Chars & out_vec)
{
if constexpr (is_big_int_v<B>)
throw Exception(ErrorCodes::NOT_IMPLEMENTED, "BitShiftRight is not implemented for big integers as second argument");
else
{
UInt8 word_size = 8;
size_t n = end - pos;
/// To prevent overflow
if (static_cast<double>(b) >= (static_cast<double>(n) * word_size) || b < 0)
{
// insert default value
out_vec.resize_fill(out_vec.size() + n);
return;
}
size_t shift_right_bytes = b / word_size;
size_t shift_right_bits = b % word_size;
const UInt8 * begin = pos;
const UInt8 * shift_right_end = end - shift_right_bytes;
const size_t old_size = out_vec.size();
const size_t new_size = old_size + n;
/// Fill 0 to the left
out_vec.resize_fill(out_vec.size() + old_size + shift_right_bytes);
out_vec.resize(new_size);
/// We start from the byte on the right and shift right shift_right_bits bit by byte
UInt8 * op_pointer = const_cast<UInt8 *>(shift_right_end);
UInt8 * out = out_vec.data() + new_size;
bitShiftRightForBytes(op_pointer, begin, out, shift_right_bits);
}
}
#if USE_EMBEDDED_COMPILER
static constexpr bool compilable = true;
static inline llvm::Value * compile(llvm::IRBuilder<> & b, llvm::Value * left, llvm::Value * right, bool is_signed)
{
if (!left->getType()->isIntegerTy())
throw Exception(ErrorCodes::LOGICAL_ERROR, "BitShiftRightImpl expected an integral type");
return is_signed ? b.CreateAShr(left, right) : b.CreateLShr(left, right);
}
#endif
};
struct NameBitShiftRight { static constexpr auto name = "bitShiftRight"; };
using FunctionBitShiftRight = BinaryArithmeticOverloadResolver<BitShiftRightImpl, NameBitShiftRight, true, false>;
}
REGISTER_FUNCTION(BitShiftRight)
{
factory.registerFunction<FunctionBitShiftRight>();
}
}
|
