duckdb 0.8.2-dev1862.0 → 0.8.2-dev1968.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (82) hide show
  1. package/binding.gyp +9 -9
  2. package/package.json +1 -1
  3. package/src/duckdb/src/common/enum_util.cpp +28 -0
  4. package/src/duckdb/src/common/types/hugeint.cpp +40 -0
  5. package/src/duckdb/src/core_functions/function_list.cpp +1 -0
  6. package/src/duckdb/src/core_functions/scalar/string/to_base.cpp +66 -0
  7. package/src/duckdb/src/execution/operator/aggregate/physical_hash_aggregate.cpp +14 -11
  8. package/src/duckdb/src/execution/operator/aggregate/physical_perfecthash_aggregate.cpp +6 -4
  9. package/src/duckdb/src/execution/operator/aggregate/physical_ungrouped_aggregate.cpp +14 -12
  10. package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp +6 -4
  11. package/src/duckdb/src/execution/operator/helper/physical_batch_collector.cpp +8 -6
  12. package/src/duckdb/src/execution/operator/helper/physical_explain_analyze.cpp +2 -2
  13. package/src/duckdb/src/execution/operator/helper/physical_limit.cpp +5 -3
  14. package/src/duckdb/src/execution/operator/helper/physical_materialized_collector.cpp +7 -5
  15. package/src/duckdb/src/execution/operator/helper/physical_vacuum.cpp +7 -5
  16. package/src/duckdb/src/execution/operator/join/physical_asof_join.cpp +5 -4
  17. package/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp +2 -2
  18. package/src/duckdb/src/execution/operator/join/physical_delim_join.cpp +13 -6
  19. package/src/duckdb/src/execution/operator/join/physical_hash_join.cpp +7 -5
  20. package/src/duckdb/src/execution/operator/join/physical_iejoin.cpp +7 -5
  21. package/src/duckdb/src/execution/operator/join/physical_nested_loop_join.cpp +7 -4
  22. package/src/duckdb/src/execution/operator/join/physical_piecewise_merge_join.cpp +8 -6
  23. package/src/duckdb/src/execution/operator/order/physical_order.cpp +7 -5
  24. package/src/duckdb/src/execution/operator/order/physical_top_n.cpp +7 -5
  25. package/src/duckdb/src/execution/operator/persistent/physical_batch_copy_to_file.cpp +8 -6
  26. package/src/duckdb/src/execution/operator/persistent/physical_batch_insert.cpp +8 -7
  27. package/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp +8 -6
  28. package/src/duckdb/src/execution/operator/persistent/physical_fixed_batch_copy.cpp +11 -9
  29. package/src/duckdb/src/execution/operator/persistent/physical_insert.cpp +10 -10
  30. package/src/duckdb/src/execution/operator/persistent/physical_update.cpp +4 -2
  31. package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp +7 -6
  32. package/src/duckdb/src/execution/physical_operator.cpp +3 -2
  33. package/src/duckdb/src/function/table/version/pragma_version.cpp +2 -2
  34. package/src/duckdb/src/include/duckdb/common/bitpacking.hpp +70 -55
  35. package/src/duckdb/src/include/duckdb/common/enum_util.hpp +8 -0
  36. package/src/duckdb/src/include/duckdb/common/enums/operator_result_type.hpp +5 -1
  37. package/src/duckdb/src/include/duckdb/common/hugeint.hpp +15 -0
  38. package/src/duckdb/src/include/duckdb/common/limits.hpp +52 -149
  39. package/src/duckdb/src/include/duckdb/common/numeric_utils.hpp +48 -0
  40. package/src/duckdb/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp +1 -1
  41. package/src/duckdb/src/include/duckdb/core_functions/scalar/operators_functions.hpp +1 -1
  42. package/src/duckdb/src/include/duckdb/core_functions/scalar/string_functions.hpp +9 -0
  43. package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp +3 -3
  44. package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_perfecthash_aggregate.hpp +1 -1
  45. package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp +3 -3
  46. package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_window.hpp +2 -2
  47. package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_batch_collector.hpp +2 -2
  48. package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_explain_analyze.hpp +1 -1
  49. package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_limit.hpp +1 -1
  50. package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_materialized_collector.hpp +1 -1
  51. package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_vacuum.hpp +2 -2
  52. package/src/duckdb/src/include/duckdb/execution/operator/join/physical_asof_join.hpp +2 -2
  53. package/src/duckdb/src/include/duckdb/execution/operator/join/physical_blockwise_nl_join.hpp +1 -1
  54. package/src/duckdb/src/include/duckdb/execution/operator/join/physical_delim_join.hpp +2 -2
  55. package/src/duckdb/src/include/duckdb/execution/operator/join/physical_hash_join.hpp +2 -2
  56. package/src/duckdb/src/include/duckdb/execution/operator/join/physical_iejoin.hpp +2 -2
  57. package/src/duckdb/src/include/duckdb/execution/operator/join/physical_nested_loop_join.hpp +2 -2
  58. package/src/duckdb/src/include/duckdb/execution/operator/join/physical_piecewise_merge_join.hpp +2 -2
  59. package/src/duckdb/src/include/duckdb/execution/operator/order/physical_order.hpp +2 -2
  60. package/src/duckdb/src/include/duckdb/execution/operator/order/physical_top_n.hpp +2 -2
  61. package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp +2 -2
  62. package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_insert.hpp +2 -2
  63. package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp +2 -2
  64. package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_fixed_batch_copy.hpp +2 -2
  65. package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp +2 -2
  66. package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_update.hpp +1 -1
  67. package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_index.hpp +2 -2
  68. package/src/duckdb/src/include/duckdb/execution/physical_operator.hpp +3 -3
  69. package/src/duckdb/src/include/duckdb/execution/physical_operator_states.hpp +11 -0
  70. package/src/duckdb/src/include/duckdb/main/extension_entries.hpp +3 -0
  71. package/src/duckdb/src/include/duckdb/parallel/pipeline.hpp +0 -3
  72. package/src/duckdb/src/include/duckdb/parallel/pipeline_executor.hpp +3 -2
  73. package/src/duckdb/src/main/relation/join_relation.cpp +1 -1
  74. package/src/duckdb/src/parallel/pipeline.cpp +0 -17
  75. package/src/duckdb/src/parallel/pipeline_executor.cpp +26 -7
  76. package/src/duckdb/src/parallel/pipeline_finish_event.cpp +55 -1
  77. package/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp +13 -3
  78. package/src/duckdb/src/storage/compression/bitpacking.cpp +87 -63
  79. package/src/duckdb/src/storage/compression/bitpacking_hugeint.cpp +295 -0
  80. package/src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp +6 -6
  81. package/src/duckdb/ub_src_core_functions_scalar_string.cpp +2 -0
  82. package/src/duckdb/ub_src_storage_compression.cpp +2 -0
@@ -214,6 +214,8 @@ enum class SetType : uint8_t;
214
214
 
215
215
  enum class SimplifiedTokenType : uint8_t;
216
216
 
217
+ enum class SinkCombineResultType : uint8_t;
218
+
217
219
  enum class SinkFinalizeType : uint8_t;
218
220
 
219
221
  enum class SinkResultType : uint8_t;
@@ -544,6 +546,9 @@ const char* EnumUtil::ToChars<SetType>(SetType value);
544
546
  template<>
545
547
  const char* EnumUtil::ToChars<SimplifiedTokenType>(SimplifiedTokenType value);
546
548
 
549
+ template<>
550
+ const char* EnumUtil::ToChars<SinkCombineResultType>(SinkCombineResultType value);
551
+
547
552
  template<>
548
553
  const char* EnumUtil::ToChars<SinkFinalizeType>(SinkFinalizeType value);
549
554
 
@@ -902,6 +907,9 @@ SetType EnumUtil::FromString<SetType>(const char *value);
902
907
  template<>
903
908
  SimplifiedTokenType EnumUtil::FromString<SimplifiedTokenType>(const char *value);
904
909
 
910
+ template<>
911
+ SinkCombineResultType EnumUtil::FromString<SinkCombineResultType>(const char *value);
912
+
905
913
  template<>
906
914
  SinkFinalizeType EnumUtil::FromString<SinkFinalizeType>(const char *value);
907
915
 
@@ -46,10 +46,14 @@ enum class SourceResultType : uint8_t { HAVE_MORE_OUTPUT, FINISHED, BLOCKED };
46
46
  //! BLOCKED means the sink is currently blocked, e.g. by some async I/O.
47
47
  enum class SinkResultType : uint8_t { NEED_MORE_INPUT, FINISHED, BLOCKED };
48
48
 
49
+ // todo comment
50
+ enum class SinkCombineResultType : uint8_t { FINISHED, BLOCKED };
51
+
49
52
  //! The SinkFinalizeType is used to indicate the result of a Finalize call on a sink
50
53
  //! There are two possible results:
51
54
  //! READY means the sink is ready for further processing
52
55
  //! NO_OUTPUT_POSSIBLE means the sink will never provide output, and any pipelines involving the sink can be skipped
53
- enum class SinkFinalizeType : uint8_t { READY, NO_OUTPUT_POSSIBLE };
56
+ //! BLOCKED means the finalize call to the sink is currently blocked, e.g. by some async I/O.
57
+ enum class SinkFinalizeType : uint8_t { READY, NO_OUTPUT_POSSIBLE, BLOCKED };
54
58
 
55
59
  } // namespace duckdb
@@ -3,6 +3,7 @@
3
3
  #include "duckdb/common/winapi.hpp"
4
4
  #include "duckdb/common/string.hpp"
5
5
  #include <stdint.h>
6
+ #include "duckdb/common/typedefs.hpp"
6
7
 
7
8
  namespace duckdb {
8
9
 
@@ -58,6 +59,20 @@ public:
58
59
  DUCKDB_API hugeint_t &operator&=(const hugeint_t &rhs);
59
60
  DUCKDB_API hugeint_t &operator|=(const hugeint_t &rhs);
60
61
  DUCKDB_API hugeint_t &operator^=(const hugeint_t &rhs);
62
+
63
+ // boolean operators
64
+ DUCKDB_API explicit operator bool() const;
65
+ DUCKDB_API bool operator!() const;
66
+
67
+ // cast operators
68
+ DUCKDB_API explicit operator uint8_t() const;
69
+ DUCKDB_API explicit operator uint16_t() const;
70
+ DUCKDB_API explicit operator uint32_t() const;
71
+ DUCKDB_API explicit operator uint64_t() const;
72
+ DUCKDB_API explicit operator int8_t() const;
73
+ DUCKDB_API explicit operator int16_t() const;
74
+ DUCKDB_API explicit operator int32_t() const;
75
+ DUCKDB_API explicit operator int64_t() const;
61
76
  };
62
77
 
63
78
  } // namespace duckdb
@@ -8,8 +8,11 @@
8
8
 
9
9
  #pragma once
10
10
 
11
+ #include "duckdb/common/hugeint.hpp"
11
12
  #include "duckdb/common/types.hpp"
12
13
 
14
+ #include <type_traits>
15
+
13
16
  // Undef annoying windows macro
14
17
  #undef max
15
18
 
@@ -21,75 +24,16 @@ template <class T>
21
24
  struct NumericLimits {
22
25
  static constexpr T Minimum() {
23
26
  return std::numeric_limits<T>::lowest();
24
- };
27
+ }
25
28
  static constexpr T Maximum() {
26
29
  return std::numeric_limits<T>::max();
27
- };
28
- DUCKDB_API static bool IsSigned();
29
- DUCKDB_API static idx_t Digits();
30
- };
31
-
32
- template <>
33
- struct NumericLimits<int8_t> {
34
- static constexpr int8_t Minimum() {
35
- return std::numeric_limits<int8_t>::lowest();
36
- };
37
- static constexpr int8_t Maximum() {
38
- return std::numeric_limits<int8_t>::max();
39
- };
40
- static bool IsSigned() {
41
- return true;
42
- }
43
- static idx_t Digits() {
44
- return 3;
45
- }
46
- };
47
- template <>
48
- struct NumericLimits<int16_t> {
49
- static constexpr int16_t Minimum() {
50
- return std::numeric_limits<int16_t>::lowest();
51
- };
52
- static constexpr int16_t Maximum() {
53
- return std::numeric_limits<int16_t>::max();
54
- };
55
- static bool IsSigned() {
56
- return true;
57
- }
58
- static idx_t Digits() {
59
- return 5;
60
- }
61
- };
62
- template <>
63
- struct NumericLimits<int32_t> {
64
- static constexpr int32_t Minimum() {
65
- return std::numeric_limits<int32_t>::lowest();
66
- };
67
- static constexpr int32_t Maximum() {
68
- return std::numeric_limits<int32_t>::max();
69
- };
70
- static bool IsSigned() {
71
- return true;
72
30
  }
73
- static idx_t Digits() {
74
- return 10;
31
+ DUCKDB_API static constexpr bool IsSigned() {
32
+ return std::is_signed<T>::value;
75
33
  }
34
+ DUCKDB_API static constexpr idx_t Digits();
76
35
  };
77
36
 
78
- template <>
79
- struct NumericLimits<int64_t> {
80
- static constexpr int64_t Minimum() {
81
- return std::numeric_limits<int64_t>::lowest();
82
- };
83
- static constexpr int64_t Maximum() {
84
- return std::numeric_limits<int64_t>::max();
85
- };
86
- static bool IsSigned() {
87
- return true;
88
- }
89
- static idx_t Digits() {
90
- return 19;
91
- }
92
- };
93
37
  template <>
94
38
  struct NumericLimits<hugeint_t> {
95
39
  static constexpr hugeint_t Minimum() {
@@ -98,104 +42,63 @@ struct NumericLimits<hugeint_t> {
98
42
  static constexpr hugeint_t Maximum() {
99
43
  return {std::numeric_limits<int64_t>::max(), std::numeric_limits<uint64_t>::max()};
100
44
  };
101
- static bool IsSigned() {
45
+ static constexpr bool IsSigned() {
102
46
  return true;
103
47
  }
104
- static idx_t Digits() {
48
+
49
+ static constexpr idx_t Digits() {
105
50
  return 39;
106
51
  }
107
52
  };
108
53
 
109
54
  template <>
110
- struct NumericLimits<uint8_t> {
111
- static constexpr uint8_t Minimum() {
112
- return std::numeric_limits<uint8_t>::lowest();
113
- };
114
- static constexpr uint8_t Maximum() {
115
- return std::numeric_limits<uint8_t>::max();
116
- };
117
- static bool IsSigned() {
118
- return false;
119
- }
120
- static idx_t Digits() {
121
- return 3;
122
- }
123
- };
55
+ constexpr idx_t NumericLimits<int8_t>::Digits() {
56
+ return 3;
57
+ }
124
58
 
125
59
  template <>
126
- struct NumericLimits<uint16_t> {
127
- static constexpr uint16_t Minimum() {
128
- return std::numeric_limits<uint16_t>::lowest();
129
- };
130
- static constexpr uint16_t Maximum() {
131
- return std::numeric_limits<uint16_t>::max();
132
- };
133
- static bool IsSigned() {
134
- return false;
135
- }
136
- static idx_t Digits() {
137
- return 5;
138
- }
139
- };
60
+ constexpr idx_t NumericLimits<int16_t>::Digits() {
61
+ return 5;
62
+ }
63
+
140
64
  template <>
141
- struct NumericLimits<uint32_t> {
142
- static constexpr uint32_t Minimum() {
143
- return std::numeric_limits<uint32_t>::lowest();
144
- };
145
- static constexpr uint32_t Maximum() {
146
- return std::numeric_limits<uint32_t>::max();
147
- };
148
- static bool IsSigned() {
149
- return false;
150
- }
151
- static idx_t Digits() {
152
- return 10;
153
- }
154
- };
65
+ constexpr idx_t NumericLimits<int32_t>::Digits() {
66
+ return 10;
67
+ }
68
+
155
69
  template <>
156
- struct NumericLimits<uint64_t> {
157
- static constexpr uint64_t Minimum() {
158
- return std::numeric_limits<uint64_t>::lowest();
159
- };
160
- static constexpr uint64_t Maximum() {
161
- return std::numeric_limits<uint64_t>::max();
162
- };
163
- static bool IsSigned() {
164
- return false;
165
- }
166
- static idx_t Digits() {
167
- return 20;
168
- }
169
- };
70
+ constexpr idx_t NumericLimits<int64_t>::Digits() {
71
+ return 19;
72
+ }
73
+
170
74
  template <>
171
- struct NumericLimits<float> {
172
- static constexpr float Minimum() {
173
- return std::numeric_limits<float>::lowest();
174
- };
175
- static constexpr float Maximum() {
176
- return std::numeric_limits<float>::max();
177
- };
178
- static bool IsSigned() {
179
- return true;
180
- }
181
- static idx_t Digits() {
182
- return 127;
183
- }
184
- };
75
+ constexpr idx_t NumericLimits<uint8_t>::Digits() {
76
+ return 3;
77
+ }
78
+
185
79
  template <>
186
- struct NumericLimits<double> {
187
- static constexpr double Minimum() {
188
- return std::numeric_limits<double>::lowest();
189
- };
190
- static constexpr double Maximum() {
191
- return std::numeric_limits<double>::max();
192
- };
193
- static bool IsSigned() {
194
- return true;
195
- }
196
- static idx_t Digits() {
197
- return 250;
198
- }
199
- };
80
+ constexpr idx_t NumericLimits<uint16_t>::Digits() {
81
+ return 5;
82
+ }
83
+
84
+ template <>
85
+ constexpr idx_t NumericLimits<uint32_t>::Digits() {
86
+ return 10;
87
+ }
88
+
89
+ template <>
90
+ constexpr idx_t NumericLimits<uint64_t>::Digits() {
91
+ return 20;
92
+ }
93
+
94
+ template <>
95
+ constexpr idx_t NumericLimits<float>::Digits() {
96
+ return 127;
97
+ }
98
+
99
+ template <>
100
+ constexpr idx_t NumericLimits<double>::Digits() {
101
+ return 250;
102
+ }
200
103
 
201
104
  } // namespace duckdb
@@ -0,0 +1,48 @@
1
+ //===----------------------------------------------------------------------===//
2
+ // DuckDB
3
+ //
4
+ // duckdb/common/numeric_utils.hpp
5
+ //
6
+ //
7
+ //===----------------------------------------------------------------------===//
8
+
9
+ #pragma once
10
+
11
+ #include <type_traits>
12
+ #include "duckdb/common/hugeint.hpp"
13
+
14
+ namespace duckdb {
15
+
16
+ template <class T>
17
+ struct MakeSigned {
18
+ using type = typename std::make_signed<T>::type;
19
+ };
20
+
21
+ template <>
22
+ struct MakeSigned<hugeint_t> {
23
+ using type = hugeint_t;
24
+ };
25
+
26
+ template <class T>
27
+ struct MakeUnsigned {
28
+ using type = typename std::make_unsigned<T>::type;
29
+ };
30
+
31
+ // hugeint_t does not actually have an unsigned variant (yet), but this is required to make compression work
32
+ // if an unsigned variant gets implemented this (probably) can be changed without breaking anything
33
+ template <>
34
+ struct MakeUnsigned<hugeint_t> {
35
+ using type = hugeint_t;
36
+ };
37
+
38
+ template <class T>
39
+ struct IsIntegral {
40
+ static constexpr bool value = std::is_integral<T>::value;
41
+ };
42
+
43
+ template <>
44
+ struct IsIntegral<hugeint_t> {
45
+ static constexpr bool value = true;
46
+ };
47
+
48
+ } // namespace duckdb
@@ -199,7 +199,7 @@ struct StringAggFun {
199
199
  static constexpr const char *Name = "string_agg";
200
200
  static constexpr const char *Parameters = "str,arg";
201
201
  static constexpr const char *Description = "Concatenates the column string values with an optional separator.";
202
- static constexpr const char *Example = "string_agg(A, '-)";
202
+ static constexpr const char *Example = "string_agg(A, '-')";
203
203
 
204
204
  static AggregateFunctionSet GetFunctions();
205
205
  };
@@ -28,7 +28,7 @@ struct BitwiseOrFun {
28
28
  static constexpr const char *Name = "|";
29
29
  static constexpr const char *Parameters = "left,right";
30
30
  static constexpr const char *Description = "Bitwise OR";
31
- static constexpr const char *Example = "32 & 3";
31
+ static constexpr const char *Example = "32 | 3";
32
32
 
33
33
  static ScalarFunctionSet GetFunctions();
34
34
  };
@@ -453,4 +453,13 @@ struct OrdFun {
453
453
  static constexpr const char *Name = "ord";
454
454
  };
455
455
 
456
+ struct ToBaseFun {
457
+ static constexpr const char *Name = "to_base";
458
+ static constexpr const char *Parameters = "number,radix,min_length";
459
+ static constexpr const char *Description = "Converts a value to a string in the given base radix, optionally padding with leading zeros to the minimum length";
460
+ static constexpr const char *Example = "to_base(42, 16)";
461
+
462
+ static ScalarFunctionSet GetFunctions();
463
+ };
464
+
456
465
  } // namespace duckdb
@@ -106,9 +106,9 @@ public:
106
106
  public:
107
107
  // Sink interface
108
108
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
109
- void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
109
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
110
110
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
111
- GlobalSinkState &gstate) const override;
111
+ OperatorSinkFinalizeInput &input) const override;
112
112
  SinkFinalizeType FinalizeInternal(Pipeline &pipeline, Event &event, ClientContext &context, GlobalSinkState &gstate,
113
113
  bool check_distinct) const;
114
114
 
@@ -141,7 +141,7 @@ private:
141
141
  SinkFinalizeType FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
142
142
  GlobalSinkState &gstate) const;
143
143
  //! Combine the distinct aggregates
144
- void CombineDistinct(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const;
144
+ void CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const;
145
145
  //! Sink the distinct aggregates for a single grouping
146
146
  void SinkDistinctGrouping(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input,
147
147
  idx_t grouping_idx) const;
@@ -46,7 +46,7 @@ public:
46
46
  public:
47
47
  // Sink interface
48
48
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
49
- void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
49
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
50
50
 
51
51
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
52
52
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
@@ -44,9 +44,9 @@ public:
44
44
  public:
45
45
  // Sink interface
46
46
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
47
- void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
47
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
48
48
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
49
- GlobalSinkState &gstate) const override;
49
+ OperatorSinkFinalizeInput &input) const override;
50
50
 
51
51
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
52
52
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
@@ -68,7 +68,7 @@ private:
68
68
  SinkFinalizeType FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
69
69
  GlobalSinkState &gstate) const;
70
70
  //! Combine the distinct aggregates
71
- void CombineDistinct(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const;
71
+ void CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const;
72
72
  //! Sink the distinct aggregates
73
73
  void SinkDistinct(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const;
74
74
  };
@@ -51,9 +51,9 @@ public:
51
51
  public:
52
52
  // Sink interface
53
53
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
54
- void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
54
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
55
55
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
56
- GlobalSinkState &gstate) const override;
56
+ OperatorSinkFinalizeInput &input) const override;
57
57
 
58
58
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
59
59
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
@@ -22,9 +22,9 @@ public:
22
22
  public:
23
23
  // Sink interface
24
24
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
25
- void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
25
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
26
26
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
27
- GlobalSinkState &gstate) const override;
27
+ OperatorSinkFinalizeInput &input) const override;
28
28
 
29
29
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
30
30
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
@@ -34,7 +34,7 @@ public:
34
34
  // Sink Interface
35
35
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
36
36
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
37
- GlobalSinkState &gstate) const override;
37
+ OperatorSinkFinalizeInput &input) const override;
38
38
 
39
39
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
40
40
 
@@ -44,7 +44,7 @@ public:
44
44
  public:
45
45
  // Sink Interface
46
46
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
47
- void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
47
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
48
48
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
49
49
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
50
50
 
@@ -24,7 +24,7 @@ public:
24
24
  public:
25
25
  // Sink interface
26
26
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
27
- void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
27
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
28
28
 
29
29
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
30
30
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
@@ -38,9 +38,9 @@ public:
38
38
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
39
39
 
40
40
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
41
- void Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const override;
41
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
42
42
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
43
- GlobalSinkState &gstate) const override;
43
+ OperatorSinkFinalizeInput &input) const override;
44
44
 
45
45
  bool IsSink() const override {
46
46
  return info->has_table;
@@ -69,9 +69,9 @@ public:
69
69
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
70
70
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
71
71
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
72
- void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
72
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
73
73
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
74
- GlobalSinkState &gstate) const override;
74
+ OperatorSinkFinalizeInput &input) const override;
75
75
 
76
76
  bool IsSink() const override {
77
77
  return true;
@@ -59,7 +59,7 @@ public:
59
59
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
60
60
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
61
61
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
62
- GlobalSinkState &gstate) const override;
62
+ OperatorSinkFinalizeInput &input) const override;
63
63
 
64
64
  bool IsSink() const override {
65
65
  return true;
@@ -35,9 +35,9 @@ public:
35
35
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
36
36
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
37
37
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
38
- void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
38
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
39
39
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
40
- GlobalSinkState &gstate) const override;
40
+ OperatorSinkFinalizeInput &input) const override;
41
41
 
42
42
  bool IsSink() const override {
43
43
  return true;
@@ -79,9 +79,9 @@ public:
79
79
 
80
80
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
81
81
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
82
- void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
82
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
83
83
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
84
- GlobalSinkState &gstate) const override;
84
+ OperatorSinkFinalizeInput &input) const override;
85
85
 
86
86
  bool IsSink() const override {
87
87
  return true;
@@ -51,9 +51,9 @@ public:
51
51
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
52
52
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
53
53
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
54
- void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
54
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
55
55
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
56
- GlobalSinkState &gstate) const override;
56
+ OperatorSinkFinalizeInput &input) const override;
57
57
 
58
58
  bool IsSink() const override {
59
59
  return true;
@@ -54,9 +54,9 @@ public:
54
54
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
55
55
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
56
56
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
57
- void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
57
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
58
58
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
59
- GlobalSinkState &gstate) const override;
59
+ OperatorSinkFinalizeInput &input) const override;
60
60
 
61
61
  bool IsSink() const override {
62
62
  return true;
@@ -60,9 +60,9 @@ public:
60
60
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
61
61
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
62
62
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
63
- void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
63
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
64
64
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
65
- GlobalSinkState &gstate) const override;
65
+ OperatorSinkFinalizeInput &input) const override;
66
66
 
67
67
  bool IsSink() const override {
68
68
  return true;
@@ -60,9 +60,9 @@ public:
60
60
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
61
61
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
62
62
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
63
- void Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const override;
63
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
64
64
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
65
- GlobalSinkState &gstate) const override;
65
+ OperatorSinkFinalizeInput &input) const override;
66
66
 
67
67
  bool IsSink() const override {
68
68
  return true;
@@ -42,9 +42,9 @@ public:
42
42
 
43
43
  public:
44
44
  SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
45
- void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
45
+ SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
46
46
  SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
47
- GlobalSinkState &gstate) const override;
47
+ OperatorSinkFinalizeInput &input) const override;
48
48
  unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
49
49
  unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
50
50