duckdb 0.8.2-dev2700.0 → 0.8.2-dev2842.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 (100) hide show
  1. package/package.json +1 -1
  2. package/src/duckdb/extension/icu/icu-makedate.cpp +12 -6
  3. package/src/duckdb/extension/json/include/json_deserializer.hpp +1 -1
  4. package/src/duckdb/extension/json/include/json_serializer.hpp +1 -1
  5. package/src/duckdb/extension/json/json_deserializer.cpp +10 -10
  6. package/src/duckdb/extension/json/json_scan.cpp +2 -2
  7. package/src/duckdb/extension/json/json_serializer.cpp +11 -10
  8. package/src/duckdb/extension/json/serialize_json.cpp +44 -44
  9. package/src/duckdb/extension/parquet/parquet_extension.cpp +11 -10
  10. package/src/duckdb/extension/parquet/serialize_parquet.cpp +6 -6
  11. package/src/duckdb/src/common/adbc/adbc.cpp +52 -21
  12. package/src/duckdb/src/common/adbc/driver_manager.cpp +12 -2
  13. package/src/duckdb/src/common/enum_util.cpp +5 -0
  14. package/src/duckdb/src/common/extra_type_info.cpp +2 -2
  15. package/src/duckdb/src/common/serializer/binary_deserializer.cpp +5 -3
  16. package/src/duckdb/src/common/serializer/binary_serializer.cpp +10 -5
  17. package/src/duckdb/src/common/types/column/column_data_collection.cpp +4 -4
  18. package/src/duckdb/src/common/types/row/row_data_collection_scanner.cpp +35 -5
  19. package/src/duckdb/src/common/types/value.cpp +33 -33
  20. package/src/duckdb/src/common/types/vector.cpp +20 -20
  21. package/src/duckdb/src/core_functions/aggregate/holistic/approximate_quantile.cpp +2 -2
  22. package/src/duckdb/src/core_functions/aggregate/holistic/quantile.cpp +6 -6
  23. package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp +4 -4
  24. package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp +4 -4
  25. package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp +283 -91
  26. package/src/duckdb/src/execution/operator/filter/physical_filter.cpp +1 -1
  27. package/src/duckdb/src/execution/operator/join/physical_comparison_join.cpp +1 -2
  28. package/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp +1 -1
  29. package/src/duckdb/src/execution/physical_plan_generator.cpp +1 -6
  30. package/src/duckdb/src/execution/window_executor.cpp +10 -1
  31. package/src/duckdb/src/function/table/read_csv.cpp +4 -4
  32. package/src/duckdb/src/function/table/table_scan.cpp +14 -14
  33. package/src/duckdb/src/function/table/version/pragma_version.cpp +5 -2
  34. package/src/duckdb/src/include/duckdb/common/adbc/adbc.hpp +2 -0
  35. package/src/duckdb/src/include/duckdb/common/enums/pending_execution_result.hpp +1 -1
  36. package/src/duckdb/src/include/duckdb/common/index_vector.hpp +2 -2
  37. package/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp +7 -3
  38. package/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp +2 -1
  39. package/src/duckdb/src/include/duckdb/common/serializer/format_deserializer.hpp +18 -17
  40. package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp +10 -9
  41. package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp +4 -0
  42. package/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp +5 -1
  43. package/src/duckdb/src/include/duckdb/execution/physical_operator.hpp +0 -2
  44. package/src/duckdb/src/include/duckdb/function/function_serialization.hpp +10 -10
  45. package/src/duckdb/src/include/duckdb/main/pending_query_result.hpp +5 -0
  46. package/src/duckdb/src/include/duckdb/main/relation/aggregate_relation.hpp +4 -1
  47. package/src/duckdb/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp +37 -63
  48. package/src/duckdb/src/include/duckdb/optimizer/join_order/cost_model.hpp +37 -0
  49. package/src/duckdb/src/include/duckdb/optimizer/join_order/join_node.hpp +14 -29
  50. package/src/duckdb/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp +7 -21
  51. package/src/duckdb/src/include/duckdb/optimizer/join_order/join_relation.hpp +0 -11
  52. package/src/duckdb/src/include/duckdb/optimizer/join_order/plan_enumerator.hpp +89 -0
  53. package/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph.hpp +17 -31
  54. package/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph_manager.hpp +113 -0
  55. package/src/duckdb/src/include/duckdb/optimizer/join_order/relation_manager.hpp +73 -0
  56. package/src/duckdb/src/include/duckdb/optimizer/join_order/relation_statistics_helper.hpp +73 -0
  57. package/src/duckdb/src/include/duckdb/parallel/task_scheduler.hpp +4 -1
  58. package/src/duckdb/src/include/duckdb/parser/group_by_node.hpp +11 -0
  59. package/src/duckdb/src/include/duckdb/parser/parser.hpp +4 -0
  60. package/src/duckdb/src/include/duckdb/planner/logical_operator.hpp +0 -2
  61. package/src/duckdb/src/include/duckdb.h +11 -1
  62. package/src/duckdb/src/main/capi/pending-c.cpp +17 -0
  63. package/src/duckdb/src/main/pending_query_result.cpp +9 -1
  64. package/src/duckdb/src/main/relation/aggregate_relation.cpp +20 -10
  65. package/src/duckdb/src/main/relation.cpp +4 -4
  66. package/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp +79 -325
  67. package/src/duckdb/src/optimizer/join_order/cost_model.cpp +19 -0
  68. package/src/duckdb/src/optimizer/join_order/join_node.cpp +5 -37
  69. package/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp +48 -1078
  70. package/src/duckdb/src/optimizer/join_order/plan_enumerator.cpp +552 -0
  71. package/src/duckdb/src/optimizer/join_order/query_graph.cpp +32 -29
  72. package/src/duckdb/src/optimizer/join_order/query_graph_manager.cpp +409 -0
  73. package/src/duckdb/src/optimizer/join_order/relation_manager.cpp +356 -0
  74. package/src/duckdb/src/optimizer/join_order/relation_statistics_helper.cpp +351 -0
  75. package/src/duckdb/src/parallel/executor.cpp +6 -0
  76. package/src/duckdb/src/parallel/task_scheduler.cpp +7 -0
  77. package/src/duckdb/src/parser/parser.cpp +18 -3
  78. package/src/duckdb/src/parser/tableref/pivotref.cpp +6 -6
  79. package/src/duckdb/src/planner/binder/statement/bind_execute.cpp +1 -1
  80. package/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp +10 -10
  81. package/src/duckdb/src/planner/expression/bound_function_expression.cpp +6 -6
  82. package/src/duckdb/src/planner/expression/bound_window_expression.cpp +24 -24
  83. package/src/duckdb/src/planner/operator/logical_extension_operator.cpp +2 -2
  84. package/src/duckdb/src/planner/operator/logical_get.cpp +26 -22
  85. package/src/duckdb/src/storage/serialization/serialize_constraint.cpp +26 -26
  86. package/src/duckdb/src/storage/serialization/serialize_create_info.cpp +66 -66
  87. package/src/duckdb/src/storage/serialization/serialize_expression.cpp +78 -78
  88. package/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp +250 -250
  89. package/src/duckdb/src/storage/serialization/serialize_macro_function.cpp +10 -10
  90. package/src/duckdb/src/storage/serialization/serialize_nodes.cpp +206 -206
  91. package/src/duckdb/src/storage/serialization/serialize_parse_info.cpp +116 -116
  92. package/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp +110 -110
  93. package/src/duckdb/src/storage/serialization/serialize_query_node.cpp +48 -48
  94. package/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp +16 -16
  95. package/src/duckdb/src/storage/serialization/serialize_statement.cpp +2 -2
  96. package/src/duckdb/src/storage/serialization/serialize_table_filter.cpp +10 -10
  97. package/src/duckdb/src/storage/serialization/serialize_tableref.cpp +54 -54
  98. package/src/duckdb/src/storage/serialization/serialize_types.cpp +22 -22
  99. package/src/duckdb/src/storage/table/update_segment.cpp +1 -1
  100. package/src/duckdb/ub_src_optimizer_join_order.cpp +10 -0
@@ -4,6 +4,8 @@
4
4
  #include "duckdb/common/types/row/row_data_collection.hpp"
5
5
  #include "duckdb/storage/buffer_manager.hpp"
6
6
 
7
+ #include <numeric>
8
+
7
9
  namespace duckdb {
8
10
 
9
11
  void RowDataCollectionScanner::AlignHeapBlocks(RowDataCollection &swizzled_block_collection,
@@ -155,6 +157,31 @@ RowDataCollectionScanner::RowDataCollectionScanner(RowDataCollection &rows_p, Ro
155
157
  ValidateUnscannedBlock();
156
158
  }
157
159
 
160
+ RowDataCollectionScanner::RowDataCollectionScanner(RowDataCollection &rows_p, RowDataCollection &heap_p,
161
+ const RowLayout &layout_p, bool external_p, idx_t block_idx,
162
+ bool flush_p)
163
+ : rows(rows_p), heap(heap_p), layout(layout_p), read_state(*this), total_count(rows.count), total_scanned(0),
164
+ external(external_p), flush(flush_p), unswizzling(!layout.AllConstant() && external && !heap.keep_pinned) {
165
+
166
+ if (unswizzling) {
167
+ D_ASSERT(rows.blocks.size() == heap.blocks.size());
168
+ }
169
+
170
+ D_ASSERT(block_idx < rows.blocks.size());
171
+ read_state.block_idx = block_idx;
172
+ read_state.entry_idx = 0;
173
+
174
+ // Pretend that we have scanned up to the start block
175
+ // and will stop at the end
176
+ auto begin = rows.blocks.begin();
177
+ auto end = begin + block_idx;
178
+ total_scanned =
179
+ std::accumulate(begin, end, idx_t(0), [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
180
+ total_count = total_scanned + (*end)->count;
181
+
182
+ ValidateUnscannedBlock();
183
+ }
184
+
158
185
  void RowDataCollectionScanner::SwizzleBlock(RowDataBlock &data_block, RowDataBlock &heap_block) {
159
186
  // Pin the data block and swizzle the pointers within the rows
160
187
  D_ASSERT(!data_block.block->IsSwizzled());
@@ -190,7 +217,7 @@ void RowDataCollectionScanner::ReSwizzle() {
190
217
  }
191
218
 
192
219
  void RowDataCollectionScanner::ValidateUnscannedBlock() const {
193
- if (unswizzling && read_state.block_idx < rows.blocks.size()) {
220
+ if (unswizzling && read_state.block_idx < rows.blocks.size() && Remaining()) {
194
221
  D_ASSERT(rows.blocks[read_state.block_idx]->block->IsSwizzled());
195
222
  }
196
223
  }
@@ -202,6 +229,9 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
202
229
  return;
203
230
  }
204
231
 
232
+ // Only flush blocks we processed.
233
+ const auto flush_block_idx = read_state.block_idx;
234
+
205
235
  const idx_t &row_width = layout.GetRowWidth();
206
236
  // Set up a batch of pointers to scan data from
207
237
  idx_t scanned = 0;
@@ -227,6 +257,8 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
227
257
  }
228
258
  // Update state indices
229
259
  read_state.entry_idx += next;
260
+ scanned += next;
261
+ total_scanned += next;
230
262
  if (read_state.entry_idx == data_block->count) {
231
263
  // Pin completed blocks so we don't lose them
232
264
  pinned_blocks.emplace_back(rows.buffer_manager.Pin(data_block->block));
@@ -238,7 +270,6 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
238
270
  read_state.entry_idx = 0;
239
271
  ValidateUnscannedBlock();
240
272
  }
241
- scanned += next;
242
273
  }
243
274
  D_ASSERT(scanned == count);
244
275
  // Deserialize the payload data
@@ -248,14 +279,13 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
248
279
  }
249
280
  chunk.SetCardinality(count);
250
281
  chunk.Verify();
251
- total_scanned += scanned;
252
282
 
253
283
  // Switch to a new set of pinned blocks
254
284
  read_state.pinned_blocks.swap(pinned_blocks);
255
285
 
256
286
  if (flush) {
257
287
  // Release blocks we have passed.
258
- for (idx_t i = 0; i < read_state.block_idx; ++i) {
288
+ for (idx_t i = flush_block_idx; i < read_state.block_idx; ++i) {
259
289
  rows.blocks[i]->block = nullptr;
260
290
  if (unswizzling) {
261
291
  heap.blocks[i]->block = nullptr;
@@ -263,7 +293,7 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
263
293
  }
264
294
  } else if (unswizzling) {
265
295
  // Reswizzle blocks we have passed so they can be flushed safely.
266
- for (idx_t i = 0; i < read_state.block_idx; ++i) {
296
+ for (idx_t i = flush_block_idx; i < read_state.block_idx; ++i) {
267
297
  auto &data_block = rows.blocks[i];
268
298
  if (data_block->block && !data_block->block->IsSwizzled()) {
269
299
  SwizzleBlock(*data_block, *heap.blocks[i]);
@@ -1763,55 +1763,55 @@ Value Value::Deserialize(Deserializer &main_source) {
1763
1763
  }
1764
1764
 
1765
1765
  void Value::FormatSerialize(FormatSerializer &serializer) const {
1766
- serializer.WriteProperty("type", type_);
1767
- serializer.WriteProperty("is_null", is_null);
1766
+ serializer.WriteProperty(100, "type", type_);
1767
+ serializer.WriteProperty(101, "is_null", is_null);
1768
1768
  if (!IsNull()) {
1769
1769
  switch (type_.InternalType()) {
1770
1770
  case PhysicalType::BOOL:
1771
- serializer.WriteProperty("value", value_.boolean);
1771
+ serializer.WriteProperty(100, "value", value_.boolean);
1772
1772
  break;
1773
1773
  case PhysicalType::INT8:
1774
- serializer.WriteProperty("value", value_.tinyint);
1774
+ serializer.WriteProperty(100, "value", value_.tinyint);
1775
1775
  break;
1776
1776
  case PhysicalType::INT16:
1777
- serializer.WriteProperty("value", value_.smallint);
1777
+ serializer.WriteProperty(100, "value", value_.smallint);
1778
1778
  break;
1779
1779
  case PhysicalType::INT32:
1780
- serializer.WriteProperty("value", value_.integer);
1780
+ serializer.WriteProperty(100, "value", value_.integer);
1781
1781
  break;
1782
1782
  case PhysicalType::INT64:
1783
- serializer.WriteProperty("value", value_.bigint);
1783
+ serializer.WriteProperty(100, "value", value_.bigint);
1784
1784
  break;
1785
1785
  case PhysicalType::UINT8:
1786
- serializer.WriteProperty("value", value_.utinyint);
1786
+ serializer.WriteProperty(100, "value", value_.utinyint);
1787
1787
  break;
1788
1788
  case PhysicalType::UINT16:
1789
- serializer.WriteProperty("value", value_.usmallint);
1789
+ serializer.WriteProperty(100, "value", value_.usmallint);
1790
1790
  break;
1791
1791
  case PhysicalType::UINT32:
1792
- serializer.WriteProperty("value", value_.uinteger);
1792
+ serializer.WriteProperty(100, "value", value_.uinteger);
1793
1793
  break;
1794
1794
  case PhysicalType::UINT64:
1795
- serializer.WriteProperty("value", value_.ubigint);
1795
+ serializer.WriteProperty(100, "value", value_.ubigint);
1796
1796
  break;
1797
1797
  case PhysicalType::INT128:
1798
- serializer.WriteProperty("value", value_.hugeint);
1798
+ serializer.WriteProperty(100, "value", value_.hugeint);
1799
1799
  break;
1800
1800
  case PhysicalType::FLOAT:
1801
- serializer.WriteProperty("value", value_.float_);
1801
+ serializer.WriteProperty(100, "value", value_.float_);
1802
1802
  break;
1803
1803
  case PhysicalType::DOUBLE:
1804
- serializer.WriteProperty("value", value_.double_);
1804
+ serializer.WriteProperty(100, "value", value_.double_);
1805
1805
  break;
1806
1806
  case PhysicalType::INTERVAL:
1807
- serializer.WriteProperty("value", value_.interval);
1807
+ serializer.WriteProperty(100, "value", value_.interval);
1808
1808
  break;
1809
1809
  case PhysicalType::VARCHAR:
1810
1810
  if (type_.id() == LogicalTypeId::BLOB) {
1811
1811
  auto blob_str = Blob::ToString(StringValue::Get(*this));
1812
- serializer.WriteProperty("value", blob_str);
1812
+ serializer.WriteProperty(100, "value", blob_str);
1813
1813
  } else {
1814
- serializer.WriteProperty("value", StringValue::Get(*this));
1814
+ serializer.WriteProperty(100, "value", StringValue::Get(*this));
1815
1815
  }
1816
1816
  break;
1817
1817
  default: {
@@ -1824,8 +1824,8 @@ void Value::FormatSerialize(FormatSerializer &serializer) const {
1824
1824
  }
1825
1825
 
1826
1826
  Value Value::FormatDeserialize(FormatDeserializer &deserializer) {
1827
- auto type = deserializer.ReadProperty<LogicalType>("type");
1828
- auto is_null = deserializer.ReadProperty<bool>("is_null");
1827
+ auto type = deserializer.ReadProperty<LogicalType>(100, "type");
1828
+ auto is_null = deserializer.ReadProperty<bool>(101, "is_null");
1829
1829
  Value new_value = Value(type);
1830
1830
  if (is_null) {
1831
1831
  return new_value;
@@ -1833,46 +1833,46 @@ Value Value::FormatDeserialize(FormatDeserializer &deserializer) {
1833
1833
  new_value.is_null = false;
1834
1834
  switch (type.InternalType()) {
1835
1835
  case PhysicalType::BOOL:
1836
- new_value.value_.boolean = deserializer.ReadProperty<bool>("value");
1836
+ new_value.value_.boolean = deserializer.ReadProperty<bool>(100, "value");
1837
1837
  break;
1838
1838
  case PhysicalType::UINT8:
1839
- new_value.value_.utinyint = deserializer.ReadProperty<uint8_t>("value");
1839
+ new_value.value_.utinyint = deserializer.ReadProperty<uint8_t>(100, "value");
1840
1840
  break;
1841
1841
  case PhysicalType::INT8:
1842
- new_value.value_.tinyint = deserializer.ReadProperty<int8_t>("value");
1842
+ new_value.value_.tinyint = deserializer.ReadProperty<int8_t>(100, "value");
1843
1843
  break;
1844
1844
  case PhysicalType::UINT16:
1845
- new_value.value_.usmallint = deserializer.ReadProperty<uint16_t>("value");
1845
+ new_value.value_.usmallint = deserializer.ReadProperty<uint16_t>(100, "value");
1846
1846
  break;
1847
1847
  case PhysicalType::INT16:
1848
- new_value.value_.smallint = deserializer.ReadProperty<int16_t>("value");
1848
+ new_value.value_.smallint = deserializer.ReadProperty<int16_t>(100, "value");
1849
1849
  break;
1850
1850
  case PhysicalType::UINT32:
1851
- new_value.value_.uinteger = deserializer.ReadProperty<uint32_t>("value");
1851
+ new_value.value_.uinteger = deserializer.ReadProperty<uint32_t>(100, "value");
1852
1852
  break;
1853
1853
  case PhysicalType::INT32:
1854
- new_value.value_.integer = deserializer.ReadProperty<int32_t>("value");
1854
+ new_value.value_.integer = deserializer.ReadProperty<int32_t>(100, "value");
1855
1855
  break;
1856
1856
  case PhysicalType::UINT64:
1857
- new_value.value_.ubigint = deserializer.ReadProperty<uint64_t>("value");
1857
+ new_value.value_.ubigint = deserializer.ReadProperty<uint64_t>(100, "value");
1858
1858
  break;
1859
1859
  case PhysicalType::INT64:
1860
- new_value.value_.bigint = deserializer.ReadProperty<int64_t>("value");
1860
+ new_value.value_.bigint = deserializer.ReadProperty<int64_t>(100, "value");
1861
1861
  break;
1862
1862
  case PhysicalType::INT128:
1863
- new_value.value_.hugeint = deserializer.ReadProperty<hugeint_t>("value");
1863
+ new_value.value_.hugeint = deserializer.ReadProperty<hugeint_t>(100, "value");
1864
1864
  break;
1865
1865
  case PhysicalType::FLOAT:
1866
- new_value.value_.float_ = deserializer.ReadProperty<float>("value");
1866
+ new_value.value_.float_ = deserializer.ReadProperty<float>(100, "value");
1867
1867
  break;
1868
1868
  case PhysicalType::DOUBLE:
1869
- new_value.value_.double_ = deserializer.ReadProperty<double>("value");
1869
+ new_value.value_.double_ = deserializer.ReadProperty<double>(100, "value");
1870
1870
  break;
1871
1871
  case PhysicalType::INTERVAL:
1872
- new_value.value_.interval = deserializer.ReadProperty<interval_t>("value");
1872
+ new_value.value_.interval = deserializer.ReadProperty<interval_t>(100, "value");
1873
1873
  break;
1874
1874
  case PhysicalType::VARCHAR: {
1875
- auto str = deserializer.ReadProperty<string>("value");
1875
+ auto str = deserializer.ReadProperty<string>(100, "value");
1876
1876
  if (type.id() == LogicalTypeId::BLOB) {
1877
1877
  new_value.value_info_ = make_shared<StringValueInfo>(Blob::ToBlob(str));
1878
1878
  } else {
@@ -999,14 +999,14 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
999
999
  ToUnifiedFormat(count, vdata);
1000
1000
 
1001
1001
  const bool all_valid = (count > 0) && !vdata.validity.AllValid();
1002
- serializer.WriteProperty("all_valid", all_valid);
1002
+ serializer.WriteProperty(100, "all_valid", all_valid);
1003
1003
  if (all_valid) {
1004
1004
  ValidityMask flat_mask(count);
1005
1005
  for (idx_t i = 0; i < count; ++i) {
1006
1006
  auto row_idx = vdata.sel->get_index(i);
1007
1007
  flat_mask.Set(i, vdata.validity.RowIsValid(row_idx));
1008
1008
  }
1009
- serializer.WriteProperty("validity", const_data_ptr_cast(flat_mask.GetData()),
1009
+ serializer.WriteProperty(101, "validity", const_data_ptr_cast(flat_mask.GetData()),
1010
1010
  flat_mask.ValidityMaskSize(count));
1011
1011
  }
1012
1012
  if (TypeIsConstantSize(logical_type.InternalType())) {
@@ -1014,14 +1014,14 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
1014
1014
  idx_t write_size = GetTypeIdSize(logical_type.InternalType()) * count;
1015
1015
  auto ptr = make_unsafe_uniq_array<data_t>(write_size);
1016
1016
  VectorOperations::WriteToStorage(*this, count, ptr.get());
1017
- serializer.WriteProperty("data", ptr.get(), write_size);
1017
+ serializer.WriteProperty(102, "data", ptr.get(), write_size);
1018
1018
  } else {
1019
1019
  switch (logical_type.InternalType()) {
1020
1020
  case PhysicalType::VARCHAR: {
1021
1021
  auto strings = UnifiedVectorFormat::GetData<string_t>(vdata);
1022
1022
 
1023
1023
  // Serialize data as a list
1024
- serializer.SetTag("data");
1024
+ serializer.SetTag(102, "data");
1025
1025
  serializer.OnListBegin(count);
1026
1026
  for (idx_t i = 0; i < count; i++) {
1027
1027
  auto idx = vdata.sel->get_index(i);
@@ -1036,7 +1036,7 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
1036
1036
  auto &entries = StructVector::GetEntries(*this);
1037
1037
 
1038
1038
  // Serialize entries as a list
1039
- serializer.SetTag("children");
1039
+ serializer.SetTag(103, "children");
1040
1040
  serializer.OnListBegin(entries.size());
1041
1041
  for (auto &entry : entries) {
1042
1042
  serializer.OnObjectBegin();
@@ -1059,17 +1059,17 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
1059
1059
  entries[i].offset = source.offset;
1060
1060
  entries[i].length = source.length;
1061
1061
  }
1062
- serializer.WriteProperty("list_size", list_size);
1063
- serializer.SetTag("entries");
1062
+ serializer.WriteProperty(104, "list_size", list_size);
1063
+ serializer.SetTag(105, "entries");
1064
1064
  serializer.OnListBegin(count);
1065
1065
  for (idx_t i = 0; i < count; i++) {
1066
1066
  serializer.OnObjectBegin();
1067
- serializer.WriteProperty("offset", entries[i].offset);
1068
- serializer.WriteProperty("length", entries[i].length);
1067
+ serializer.WriteProperty(100, "offset", entries[i].offset);
1068
+ serializer.WriteProperty(101, "length", entries[i].length);
1069
1069
  serializer.OnObjectEnd();
1070
1070
  }
1071
1071
  serializer.OnListEnd(count);
1072
- serializer.SetTag("child");
1072
+ serializer.SetTag(106, "child");
1073
1073
  serializer.OnObjectBegin();
1074
1074
  child.FormatSerialize(serializer, list_size);
1075
1075
  serializer.OnObjectEnd();
@@ -1086,24 +1086,24 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
1086
1086
 
1087
1087
  auto &validity = FlatVector::Validity(*this);
1088
1088
  validity.Reset();
1089
- const auto has_validity = deserializer.ReadProperty<bool>("all_valid");
1089
+ const auto has_validity = deserializer.ReadProperty<bool>(100, "all_valid");
1090
1090
  if (has_validity) {
1091
1091
  validity.Initialize(count);
1092
- deserializer.ReadProperty("validity", data_ptr_cast(validity.GetData()), validity.ValidityMaskSize(count));
1092
+ deserializer.ReadProperty(101, "validity", data_ptr_cast(validity.GetData()), validity.ValidityMaskSize(count));
1093
1093
  }
1094
1094
 
1095
1095
  if (TypeIsConstantSize(logical_type.InternalType())) {
1096
1096
  // constant size type: read fixed amount of data
1097
1097
  auto column_size = GetTypeIdSize(logical_type.InternalType()) * count;
1098
1098
  auto ptr = make_unsafe_uniq_array<data_t>(column_size);
1099
- deserializer.ReadProperty("data", ptr.get(), column_size);
1099
+ deserializer.ReadProperty(102, "data", ptr.get(), column_size);
1100
1100
 
1101
1101
  VectorOperations::ReadFromStorage(ptr.get(), count, *this);
1102
1102
  } else {
1103
1103
  switch (logical_type.InternalType()) {
1104
1104
  case PhysicalType::VARCHAR: {
1105
1105
  auto strings = FlatVector::GetData<string_t>(*this);
1106
- deserializer.SetTag("data");
1106
+ deserializer.SetTag(102, "data");
1107
1107
  auto read_count = deserializer.OnListBegin();
1108
1108
  D_ASSERT(read_count == count);
1109
1109
  (void)read_count; // otherwise unused variable error in release mode
@@ -1122,7 +1122,7 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
1122
1122
  case PhysicalType::STRUCT: {
1123
1123
  auto &entries = StructVector::GetEntries(*this);
1124
1124
  // Deserialize entries as a list
1125
- deserializer.SetTag("children");
1125
+ deserializer.SetTag(103, "children");
1126
1126
  auto read_size = deserializer.OnListBegin();
1127
1127
  D_ASSERT(read_size == entries.size());
1128
1128
  (void)read_size;
@@ -1136,26 +1136,26 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
1136
1136
  }
1137
1137
  case PhysicalType::LIST: {
1138
1138
  // Read the list size
1139
- auto list_size = deserializer.ReadProperty<uint64_t>("list_size");
1139
+ auto list_size = deserializer.ReadProperty<uint64_t>(104, "list_size");
1140
1140
  ListVector::Reserve(*this, list_size);
1141
1141
  ListVector::SetListSize(*this, list_size);
1142
1142
 
1143
1143
  // Read the entries
1144
1144
  auto list_entries = FlatVector::GetData<list_entry_t>(*this);
1145
- deserializer.SetTag("entries");
1145
+ deserializer.SetTag(105, "entries");
1146
1146
  auto entries_count = deserializer.OnListBegin();
1147
1147
  D_ASSERT(entries_count == count);
1148
1148
  (void)entries_count;
1149
1149
  for (idx_t i = 0; i < count; i++) {
1150
1150
  deserializer.OnObjectBegin();
1151
- deserializer.ReadProperty("offset", list_entries[i].offset);
1152
- deserializer.ReadProperty("length", list_entries[i].length);
1151
+ deserializer.ReadProperty(100, "offset", list_entries[i].offset);
1152
+ deserializer.ReadProperty(101, "length", list_entries[i].length);
1153
1153
  deserializer.OnObjectEnd();
1154
1154
  }
1155
1155
  deserializer.OnListEnd();
1156
1156
 
1157
1157
  // Read the child vector
1158
- deserializer.SetTag("child");
1158
+ deserializer.SetTag(106, "child");
1159
1159
  auto &child = ListVector::GetEntry(*this);
1160
1160
  deserializer.OnObjectBegin();
1161
1161
  child.FormatDeserialize(deserializer, list_size);
@@ -55,12 +55,12 @@ struct ApproximateQuantileBindData : public FunctionData {
55
55
  static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
56
56
  const AggregateFunction &function) {
57
57
  auto &bind_data = bind_data_p->Cast<ApproximateQuantileBindData>();
58
- serializer.WriteProperty("quantiles", bind_data.quantiles);
58
+ serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
59
59
  }
60
60
 
61
61
  static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
62
62
  auto result = make_uniq<ApproximateQuantileBindData>();
63
- deserializer.ReadProperty("quantiles", result->quantiles);
63
+ deserializer.ReadProperty(100, "quantiles", result->quantiles);
64
64
  return std::move(result);
65
65
  }
66
66
 
@@ -461,16 +461,16 @@ struct QuantileBindData : public FunctionData {
461
461
  static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
462
462
  const AggregateFunction &function) {
463
463
  auto &bind_data = bind_data_p->Cast<QuantileBindData>();
464
- serializer.WriteProperty("quantiles", bind_data.quantiles);
465
- serializer.WriteProperty("order", bind_data.order);
466
- serializer.WriteProperty("desc", bind_data.desc);
464
+ serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
465
+ serializer.WriteProperty(101, "order", bind_data.order);
466
+ serializer.WriteProperty(102, "desc", bind_data.desc);
467
467
  }
468
468
 
469
469
  static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
470
470
  auto result = make_uniq<QuantileBindData>();
471
- deserializer.ReadProperty("quantiles", result->quantiles);
472
- deserializer.ReadProperty("order", result->order);
473
- deserializer.ReadProperty("desc", result->desc);
471
+ deserializer.ReadProperty(100, "quantiles", result->quantiles);
472
+ deserializer.ReadProperty(101, "order", result->order);
473
+ deserializer.ReadProperty(102, "desc", result->desc);
474
474
  return std::move(result);
475
475
  }
476
476
 
@@ -87,14 +87,14 @@ struct ReservoirQuantileBindData : public FunctionData {
87
87
  static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
88
88
  const AggregateFunction &function) {
89
89
  auto &bind_data = bind_data_p->Cast<ReservoirQuantileBindData>();
90
- serializer.WriteProperty("quantiles", bind_data.quantiles);
91
- serializer.WriteProperty("sample_size", bind_data.sample_size);
90
+ serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
91
+ serializer.WriteProperty(101, "sample_size", bind_data.sample_size);
92
92
  }
93
93
 
94
94
  static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
95
95
  auto result = make_uniq<ReservoirQuantileBindData>();
96
- deserializer.ReadProperty("quantiles", result->quantiles);
97
- deserializer.ReadProperty("sample_size", result->sample_size);
96
+ deserializer.ReadProperty(100, "quantiles", result->quantiles);
97
+ deserializer.ReadProperty(101, "sample_size", result->sample_size);
98
98
  return std::move(result);
99
99
  }
100
100
 
@@ -34,13 +34,13 @@ public:
34
34
  static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
35
35
  const ScalarFunction &function) {
36
36
  auto &bind_data = bind_data_p->Cast<ListLambdaBindData>();
37
- serializer.WriteProperty("stype", bind_data.stype);
38
- serializer.WriteOptionalProperty("lambda_expr", bind_data.lambda_expr);
37
+ serializer.WriteProperty(100, "stype", bind_data.stype);
38
+ serializer.WriteOptionalProperty(101, "lambda_expr", bind_data.lambda_expr);
39
39
  }
40
40
 
41
41
  static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, ScalarFunction &function) {
42
- auto stype = deserializer.ReadProperty<LogicalType>("stype");
43
- auto lambda_expr = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("lambda_expr");
42
+ auto stype = deserializer.ReadProperty<LogicalType>(100, "stype");
43
+ auto lambda_expr = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(101, "lambda_expr");
44
44
  return make_uniq<ListLambdaBindData>(stype, std::move(lambda_expr));
45
45
  }
46
46
  };