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
@@ -20,11 +20,11 @@
20
20
  namespace duckdb {
21
21
 
22
22
  void ParseInfo::FormatSerialize(FormatSerializer &serializer) const {
23
- serializer.WriteProperty("info_type", info_type);
23
+ serializer.WriteProperty(100, "info_type", info_type);
24
24
  }
25
25
 
26
26
  unique_ptr<ParseInfo> ParseInfo::FormatDeserialize(FormatDeserializer &deserializer) {
27
- auto info_type = deserializer.ReadProperty<ParseInfoType>("info_type");
27
+ auto info_type = deserializer.ReadProperty<ParseInfoType>(100, "info_type");
28
28
  unique_ptr<ParseInfo> result;
29
29
  switch (info_type) {
30
30
  case ParseInfoType::ALTER_INFO:
@@ -62,21 +62,21 @@ unique_ptr<ParseInfo> ParseInfo::FormatDeserialize(FormatDeserializer &deseriali
62
62
 
63
63
  void AlterInfo::FormatSerialize(FormatSerializer &serializer) const {
64
64
  ParseInfo::FormatSerialize(serializer);
65
- serializer.WriteProperty("type", type);
66
- serializer.WriteProperty("catalog", catalog);
67
- serializer.WriteProperty("schema", schema);
68
- serializer.WriteProperty("name", name);
69
- serializer.WriteProperty("if_not_found", if_not_found);
70
- serializer.WriteProperty("allow_internal", allow_internal);
65
+ serializer.WriteProperty(200, "type", type);
66
+ serializer.WriteProperty(201, "catalog", catalog);
67
+ serializer.WriteProperty(202, "schema", schema);
68
+ serializer.WriteProperty(203, "name", name);
69
+ serializer.WriteProperty(204, "if_not_found", if_not_found);
70
+ serializer.WriteProperty(205, "allow_internal", allow_internal);
71
71
  }
72
72
 
73
73
  unique_ptr<ParseInfo> AlterInfo::FormatDeserialize(FormatDeserializer &deserializer) {
74
- auto type = deserializer.ReadProperty<AlterType>("type");
75
- auto catalog = deserializer.ReadProperty<string>("catalog");
76
- auto schema = deserializer.ReadProperty<string>("schema");
77
- auto name = deserializer.ReadProperty<string>("name");
78
- auto if_not_found = deserializer.ReadProperty<OnEntryNotFound>("if_not_found");
79
- auto allow_internal = deserializer.ReadProperty<bool>("allow_internal");
74
+ auto type = deserializer.ReadProperty<AlterType>(200, "type");
75
+ auto catalog = deserializer.ReadProperty<string>(201, "catalog");
76
+ auto schema = deserializer.ReadProperty<string>(202, "schema");
77
+ auto name = deserializer.ReadProperty<string>(203, "name");
78
+ auto if_not_found = deserializer.ReadProperty<OnEntryNotFound>(204, "if_not_found");
79
+ auto allow_internal = deserializer.ReadProperty<bool>(205, "allow_internal");
80
80
  unique_ptr<AlterInfo> result;
81
81
  switch (type) {
82
82
  case AlterType::ALTER_TABLE:
@@ -98,11 +98,11 @@ unique_ptr<ParseInfo> AlterInfo::FormatDeserialize(FormatDeserializer &deseriali
98
98
 
99
99
  void AlterTableInfo::FormatSerialize(FormatSerializer &serializer) const {
100
100
  AlterInfo::FormatSerialize(serializer);
101
- serializer.WriteProperty("alter_table_type", alter_table_type);
101
+ serializer.WriteProperty(300, "alter_table_type", alter_table_type);
102
102
  }
103
103
 
104
104
  unique_ptr<AlterInfo> AlterTableInfo::FormatDeserialize(FormatDeserializer &deserializer) {
105
- auto alter_table_type = deserializer.ReadProperty<AlterTableType>("alter_table_type");
105
+ auto alter_table_type = deserializer.ReadProperty<AlterTableType>(300, "alter_table_type");
106
106
  unique_ptr<AlterTableInfo> result;
107
107
  switch (alter_table_type) {
108
108
  case AlterTableType::ADD_COLUMN:
@@ -140,11 +140,11 @@ unique_ptr<AlterInfo> AlterTableInfo::FormatDeserialize(FormatDeserializer &dese
140
140
 
141
141
  void AlterViewInfo::FormatSerialize(FormatSerializer &serializer) const {
142
142
  AlterInfo::FormatSerialize(serializer);
143
- serializer.WriteProperty("alter_view_type", alter_view_type);
143
+ serializer.WriteProperty(300, "alter_view_type", alter_view_type);
144
144
  }
145
145
 
146
146
  unique_ptr<AlterInfo> AlterViewInfo::FormatDeserialize(FormatDeserializer &deserializer) {
147
- auto alter_view_type = deserializer.ReadProperty<AlterViewType>("alter_view_type");
147
+ auto alter_view_type = deserializer.ReadProperty<AlterViewType>(300, "alter_view_type");
148
148
  unique_ptr<AlterViewInfo> result;
149
149
  switch (alter_view_type) {
150
150
  case AlterViewType::RENAME_VIEW:
@@ -158,260 +158,260 @@ unique_ptr<AlterInfo> AlterViewInfo::FormatDeserialize(FormatDeserializer &deser
158
158
 
159
159
  void AddColumnInfo::FormatSerialize(FormatSerializer &serializer) const {
160
160
  AlterTableInfo::FormatSerialize(serializer);
161
- serializer.WriteProperty("new_column", new_column);
162
- serializer.WriteProperty("if_column_not_exists", if_column_not_exists);
161
+ serializer.WriteProperty(400, "new_column", new_column);
162
+ serializer.WriteProperty(401, "if_column_not_exists", if_column_not_exists);
163
163
  }
164
164
 
165
165
  unique_ptr<AlterTableInfo> AddColumnInfo::FormatDeserialize(FormatDeserializer &deserializer) {
166
- auto new_column = deserializer.ReadProperty<ColumnDefinition>("new_column");
166
+ auto new_column = deserializer.ReadProperty<ColumnDefinition>(400, "new_column");
167
167
  auto result = duckdb::unique_ptr<AddColumnInfo>(new AddColumnInfo(std::move(new_column)));
168
- deserializer.ReadProperty("if_column_not_exists", result->if_column_not_exists);
168
+ deserializer.ReadProperty(401, "if_column_not_exists", result->if_column_not_exists);
169
169
  return std::move(result);
170
170
  }
171
171
 
172
172
  void AlterForeignKeyInfo::FormatSerialize(FormatSerializer &serializer) const {
173
173
  AlterTableInfo::FormatSerialize(serializer);
174
- serializer.WriteProperty("fk_table", fk_table);
175
- serializer.WriteProperty("pk_columns", pk_columns);
176
- serializer.WriteProperty("fk_columns", fk_columns);
177
- serializer.WriteProperty("pk_keys", pk_keys);
178
- serializer.WriteProperty("fk_keys", fk_keys);
179
- serializer.WriteProperty("alter_fk_type", type);
174
+ serializer.WriteProperty(400, "fk_table", fk_table);
175
+ serializer.WriteProperty(401, "pk_columns", pk_columns);
176
+ serializer.WriteProperty(402, "fk_columns", fk_columns);
177
+ serializer.WriteProperty(403, "pk_keys", pk_keys);
178
+ serializer.WriteProperty(404, "fk_keys", fk_keys);
179
+ serializer.WriteProperty(405, "alter_fk_type", type);
180
180
  }
181
181
 
182
182
  unique_ptr<AlterTableInfo> AlterForeignKeyInfo::FormatDeserialize(FormatDeserializer &deserializer) {
183
183
  auto result = duckdb::unique_ptr<AlterForeignKeyInfo>(new AlterForeignKeyInfo());
184
- deserializer.ReadProperty("fk_table", result->fk_table);
185
- deserializer.ReadProperty("pk_columns", result->pk_columns);
186
- deserializer.ReadProperty("fk_columns", result->fk_columns);
187
- deserializer.ReadProperty("pk_keys", result->pk_keys);
188
- deserializer.ReadProperty("fk_keys", result->fk_keys);
189
- deserializer.ReadProperty("alter_fk_type", result->type);
184
+ deserializer.ReadProperty(400, "fk_table", result->fk_table);
185
+ deserializer.ReadProperty(401, "pk_columns", result->pk_columns);
186
+ deserializer.ReadProperty(402, "fk_columns", result->fk_columns);
187
+ deserializer.ReadProperty(403, "pk_keys", result->pk_keys);
188
+ deserializer.ReadProperty(404, "fk_keys", result->fk_keys);
189
+ deserializer.ReadProperty(405, "alter_fk_type", result->type);
190
190
  return std::move(result);
191
191
  }
192
192
 
193
193
  void AttachInfo::FormatSerialize(FormatSerializer &serializer) const {
194
194
  ParseInfo::FormatSerialize(serializer);
195
- serializer.WriteProperty("name", name);
196
- serializer.WriteProperty("path", path);
197
- serializer.WriteProperty("options", options);
195
+ serializer.WriteProperty(200, "name", name);
196
+ serializer.WriteProperty(201, "path", path);
197
+ serializer.WriteProperty(202, "options", options);
198
198
  }
199
199
 
200
200
  unique_ptr<ParseInfo> AttachInfo::FormatDeserialize(FormatDeserializer &deserializer) {
201
201
  auto result = duckdb::unique_ptr<AttachInfo>(new AttachInfo());
202
- deserializer.ReadProperty("name", result->name);
203
- deserializer.ReadProperty("path", result->path);
204
- deserializer.ReadProperty("options", result->options);
202
+ deserializer.ReadProperty(200, "name", result->name);
203
+ deserializer.ReadProperty(201, "path", result->path);
204
+ deserializer.ReadProperty(202, "options", result->options);
205
205
  return std::move(result);
206
206
  }
207
207
 
208
208
  void ChangeColumnTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
209
209
  AlterTableInfo::FormatSerialize(serializer);
210
- serializer.WriteProperty("column_name", column_name);
211
- serializer.WriteProperty("target_type", target_type);
212
- serializer.WriteProperty("expression", *expression);
210
+ serializer.WriteProperty(400, "column_name", column_name);
211
+ serializer.WriteProperty(401, "target_type", target_type);
212
+ serializer.WriteProperty(402, "expression", *expression);
213
213
  }
214
214
 
215
215
  unique_ptr<AlterTableInfo> ChangeColumnTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
216
216
  auto result = duckdb::unique_ptr<ChangeColumnTypeInfo>(new ChangeColumnTypeInfo());
217
- deserializer.ReadProperty("column_name", result->column_name);
218
- deserializer.ReadProperty("target_type", result->target_type);
219
- deserializer.ReadProperty("expression", result->expression);
217
+ deserializer.ReadProperty(400, "column_name", result->column_name);
218
+ deserializer.ReadProperty(401, "target_type", result->target_type);
219
+ deserializer.ReadProperty(402, "expression", result->expression);
220
220
  return std::move(result);
221
221
  }
222
222
 
223
223
  void CopyInfo::FormatSerialize(FormatSerializer &serializer) const {
224
224
  ParseInfo::FormatSerialize(serializer);
225
- serializer.WriteProperty("catalog", catalog);
226
- serializer.WriteProperty("schema", schema);
227
- serializer.WriteProperty("table", table);
228
- serializer.WriteProperty("select_list", select_list);
229
- serializer.WriteProperty("is_from", is_from);
230
- serializer.WriteProperty("format", format);
231
- serializer.WriteProperty("file_path", file_path);
232
- serializer.WriteProperty("options", options);
225
+ serializer.WriteProperty(200, "catalog", catalog);
226
+ serializer.WriteProperty(201, "schema", schema);
227
+ serializer.WriteProperty(202, "table", table);
228
+ serializer.WriteProperty(203, "select_list", select_list);
229
+ serializer.WriteProperty(204, "is_from", is_from);
230
+ serializer.WriteProperty(205, "format", format);
231
+ serializer.WriteProperty(206, "file_path", file_path);
232
+ serializer.WriteProperty(207, "options", options);
233
233
  }
234
234
 
235
235
  unique_ptr<ParseInfo> CopyInfo::FormatDeserialize(FormatDeserializer &deserializer) {
236
236
  auto result = duckdb::unique_ptr<CopyInfo>(new CopyInfo());
237
- deserializer.ReadProperty("catalog", result->catalog);
238
- deserializer.ReadProperty("schema", result->schema);
239
- deserializer.ReadProperty("table", result->table);
240
- deserializer.ReadProperty("select_list", result->select_list);
241
- deserializer.ReadProperty("is_from", result->is_from);
242
- deserializer.ReadProperty("format", result->format);
243
- deserializer.ReadProperty("file_path", result->file_path);
244
- deserializer.ReadProperty("options", result->options);
237
+ deserializer.ReadProperty(200, "catalog", result->catalog);
238
+ deserializer.ReadProperty(201, "schema", result->schema);
239
+ deserializer.ReadProperty(202, "table", result->table);
240
+ deserializer.ReadProperty(203, "select_list", result->select_list);
241
+ deserializer.ReadProperty(204, "is_from", result->is_from);
242
+ deserializer.ReadProperty(205, "format", result->format);
243
+ deserializer.ReadProperty(206, "file_path", result->file_path);
244
+ deserializer.ReadProperty(207, "options", result->options);
245
245
  return std::move(result);
246
246
  }
247
247
 
248
248
  void DetachInfo::FormatSerialize(FormatSerializer &serializer) const {
249
249
  ParseInfo::FormatSerialize(serializer);
250
- serializer.WriteProperty("name", name);
251
- serializer.WriteProperty("if_not_found", if_not_found);
250
+ serializer.WriteProperty(200, "name", name);
251
+ serializer.WriteProperty(201, "if_not_found", if_not_found);
252
252
  }
253
253
 
254
254
  unique_ptr<ParseInfo> DetachInfo::FormatDeserialize(FormatDeserializer &deserializer) {
255
255
  auto result = duckdb::unique_ptr<DetachInfo>(new DetachInfo());
256
- deserializer.ReadProperty("name", result->name);
257
- deserializer.ReadProperty("if_not_found", result->if_not_found);
256
+ deserializer.ReadProperty(200, "name", result->name);
257
+ deserializer.ReadProperty(201, "if_not_found", result->if_not_found);
258
258
  return std::move(result);
259
259
  }
260
260
 
261
261
  void DropInfo::FormatSerialize(FormatSerializer &serializer) const {
262
262
  ParseInfo::FormatSerialize(serializer);
263
- serializer.WriteProperty("type", type);
264
- serializer.WriteProperty("catalog", catalog);
265
- serializer.WriteProperty("schema", schema);
266
- serializer.WriteProperty("name", name);
267
- serializer.WriteProperty("if_not_found", if_not_found);
268
- serializer.WriteProperty("cascade", cascade);
269
- serializer.WriteProperty("allow_drop_internal", allow_drop_internal);
263
+ serializer.WriteProperty(200, "type", type);
264
+ serializer.WriteProperty(201, "catalog", catalog);
265
+ serializer.WriteProperty(202, "schema", schema);
266
+ serializer.WriteProperty(203, "name", name);
267
+ serializer.WriteProperty(204, "if_not_found", if_not_found);
268
+ serializer.WriteProperty(205, "cascade", cascade);
269
+ serializer.WriteProperty(206, "allow_drop_internal", allow_drop_internal);
270
270
  }
271
271
 
272
272
  unique_ptr<ParseInfo> DropInfo::FormatDeserialize(FormatDeserializer &deserializer) {
273
273
  auto result = duckdb::unique_ptr<DropInfo>(new DropInfo());
274
- deserializer.ReadProperty("type", result->type);
275
- deserializer.ReadProperty("catalog", result->catalog);
276
- deserializer.ReadProperty("schema", result->schema);
277
- deserializer.ReadProperty("name", result->name);
278
- deserializer.ReadProperty("if_not_found", result->if_not_found);
279
- deserializer.ReadProperty("cascade", result->cascade);
280
- deserializer.ReadProperty("allow_drop_internal", result->allow_drop_internal);
274
+ deserializer.ReadProperty(200, "type", result->type);
275
+ deserializer.ReadProperty(201, "catalog", result->catalog);
276
+ deserializer.ReadProperty(202, "schema", result->schema);
277
+ deserializer.ReadProperty(203, "name", result->name);
278
+ deserializer.ReadProperty(204, "if_not_found", result->if_not_found);
279
+ deserializer.ReadProperty(205, "cascade", result->cascade);
280
+ deserializer.ReadProperty(206, "allow_drop_internal", result->allow_drop_internal);
281
281
  return std::move(result);
282
282
  }
283
283
 
284
284
  void DropNotNullInfo::FormatSerialize(FormatSerializer &serializer) const {
285
285
  AlterTableInfo::FormatSerialize(serializer);
286
- serializer.WriteProperty("column_name", column_name);
286
+ serializer.WriteProperty(400, "column_name", column_name);
287
287
  }
288
288
 
289
289
  unique_ptr<AlterTableInfo> DropNotNullInfo::FormatDeserialize(FormatDeserializer &deserializer) {
290
290
  auto result = duckdb::unique_ptr<DropNotNullInfo>(new DropNotNullInfo());
291
- deserializer.ReadProperty("column_name", result->column_name);
291
+ deserializer.ReadProperty(400, "column_name", result->column_name);
292
292
  return std::move(result);
293
293
  }
294
294
 
295
295
  void LoadInfo::FormatSerialize(FormatSerializer &serializer) const {
296
296
  ParseInfo::FormatSerialize(serializer);
297
- serializer.WriteProperty("filename", filename);
298
- serializer.WriteProperty("load_type", load_type);
297
+ serializer.WriteProperty(200, "filename", filename);
298
+ serializer.WriteProperty(201, "load_type", load_type);
299
299
  }
300
300
 
301
301
  unique_ptr<ParseInfo> LoadInfo::FormatDeserialize(FormatDeserializer &deserializer) {
302
302
  auto result = duckdb::unique_ptr<LoadInfo>(new LoadInfo());
303
- deserializer.ReadProperty("filename", result->filename);
304
- deserializer.ReadProperty("load_type", result->load_type);
303
+ deserializer.ReadProperty(200, "filename", result->filename);
304
+ deserializer.ReadProperty(201, "load_type", result->load_type);
305
305
  return std::move(result);
306
306
  }
307
307
 
308
308
  void PragmaInfo::FormatSerialize(FormatSerializer &serializer) const {
309
309
  ParseInfo::FormatSerialize(serializer);
310
- serializer.WriteProperty("name", name);
311
- serializer.WriteProperty("parameters", parameters);
312
- serializer.WriteProperty("named_parameters", named_parameters);
310
+ serializer.WriteProperty(200, "name", name);
311
+ serializer.WriteProperty(201, "parameters", parameters);
312
+ serializer.WriteProperty(202, "named_parameters", named_parameters);
313
313
  }
314
314
 
315
315
  unique_ptr<ParseInfo> PragmaInfo::FormatDeserialize(FormatDeserializer &deserializer) {
316
316
  auto result = duckdb::unique_ptr<PragmaInfo>(new PragmaInfo());
317
- deserializer.ReadProperty("name", result->name);
318
- deserializer.ReadProperty("parameters", result->parameters);
319
- deserializer.ReadProperty("named_parameters", result->named_parameters);
317
+ deserializer.ReadProperty(200, "name", result->name);
318
+ deserializer.ReadProperty(201, "parameters", result->parameters);
319
+ deserializer.ReadProperty(202, "named_parameters", result->named_parameters);
320
320
  return std::move(result);
321
321
  }
322
322
 
323
323
  void RemoveColumnInfo::FormatSerialize(FormatSerializer &serializer) const {
324
324
  AlterTableInfo::FormatSerialize(serializer);
325
- serializer.WriteProperty("removed_column", removed_column);
326
- serializer.WriteProperty("if_column_exists", if_column_exists);
327
- serializer.WriteProperty("cascade", cascade);
325
+ serializer.WriteProperty(400, "removed_column", removed_column);
326
+ serializer.WriteProperty(401, "if_column_exists", if_column_exists);
327
+ serializer.WriteProperty(402, "cascade", cascade);
328
328
  }
329
329
 
330
330
  unique_ptr<AlterTableInfo> RemoveColumnInfo::FormatDeserialize(FormatDeserializer &deserializer) {
331
331
  auto result = duckdb::unique_ptr<RemoveColumnInfo>(new RemoveColumnInfo());
332
- deserializer.ReadProperty("removed_column", result->removed_column);
333
- deserializer.ReadProperty("if_column_exists", result->if_column_exists);
334
- deserializer.ReadProperty("cascade", result->cascade);
332
+ deserializer.ReadProperty(400, "removed_column", result->removed_column);
333
+ deserializer.ReadProperty(401, "if_column_exists", result->if_column_exists);
334
+ deserializer.ReadProperty(402, "cascade", result->cascade);
335
335
  return std::move(result);
336
336
  }
337
337
 
338
338
  void RenameColumnInfo::FormatSerialize(FormatSerializer &serializer) const {
339
339
  AlterTableInfo::FormatSerialize(serializer);
340
- serializer.WriteProperty("old_name", old_name);
341
- serializer.WriteProperty("new_name", new_name);
340
+ serializer.WriteProperty(400, "old_name", old_name);
341
+ serializer.WriteProperty(401, "new_name", new_name);
342
342
  }
343
343
 
344
344
  unique_ptr<AlterTableInfo> RenameColumnInfo::FormatDeserialize(FormatDeserializer &deserializer) {
345
345
  auto result = duckdb::unique_ptr<RenameColumnInfo>(new RenameColumnInfo());
346
- deserializer.ReadProperty("old_name", result->old_name);
347
- deserializer.ReadProperty("new_name", result->new_name);
346
+ deserializer.ReadProperty(400, "old_name", result->old_name);
347
+ deserializer.ReadProperty(401, "new_name", result->new_name);
348
348
  return std::move(result);
349
349
  }
350
350
 
351
351
  void RenameTableInfo::FormatSerialize(FormatSerializer &serializer) const {
352
352
  AlterTableInfo::FormatSerialize(serializer);
353
- serializer.WriteProperty("new_table_name", new_table_name);
353
+ serializer.WriteProperty(400, "new_table_name", new_table_name);
354
354
  }
355
355
 
356
356
  unique_ptr<AlterTableInfo> RenameTableInfo::FormatDeserialize(FormatDeserializer &deserializer) {
357
357
  auto result = duckdb::unique_ptr<RenameTableInfo>(new RenameTableInfo());
358
- deserializer.ReadProperty("new_table_name", result->new_table_name);
358
+ deserializer.ReadProperty(400, "new_table_name", result->new_table_name);
359
359
  return std::move(result);
360
360
  }
361
361
 
362
362
  void RenameViewInfo::FormatSerialize(FormatSerializer &serializer) const {
363
363
  AlterViewInfo::FormatSerialize(serializer);
364
- serializer.WriteProperty("new_view_name", new_view_name);
364
+ serializer.WriteProperty(400, "new_view_name", new_view_name);
365
365
  }
366
366
 
367
367
  unique_ptr<AlterViewInfo> RenameViewInfo::FormatDeserialize(FormatDeserializer &deserializer) {
368
368
  auto result = duckdb::unique_ptr<RenameViewInfo>(new RenameViewInfo());
369
- deserializer.ReadProperty("new_view_name", result->new_view_name);
369
+ deserializer.ReadProperty(400, "new_view_name", result->new_view_name);
370
370
  return std::move(result);
371
371
  }
372
372
 
373
373
  void SetDefaultInfo::FormatSerialize(FormatSerializer &serializer) const {
374
374
  AlterTableInfo::FormatSerialize(serializer);
375
- serializer.WriteProperty("column_name", column_name);
376
- serializer.WriteOptionalProperty("expression", expression);
375
+ serializer.WriteProperty(400, "column_name", column_name);
376
+ serializer.WriteOptionalProperty(401, "expression", expression);
377
377
  }
378
378
 
379
379
  unique_ptr<AlterTableInfo> SetDefaultInfo::FormatDeserialize(FormatDeserializer &deserializer) {
380
380
  auto result = duckdb::unique_ptr<SetDefaultInfo>(new SetDefaultInfo());
381
- deserializer.ReadProperty("column_name", result->column_name);
382
- deserializer.ReadOptionalProperty("expression", result->expression);
381
+ deserializer.ReadProperty(400, "column_name", result->column_name);
382
+ deserializer.ReadOptionalProperty(401, "expression", result->expression);
383
383
  return std::move(result);
384
384
  }
385
385
 
386
386
  void SetNotNullInfo::FormatSerialize(FormatSerializer &serializer) const {
387
387
  AlterTableInfo::FormatSerialize(serializer);
388
- serializer.WriteProperty("column_name", column_name);
388
+ serializer.WriteProperty(400, "column_name", column_name);
389
389
  }
390
390
 
391
391
  unique_ptr<AlterTableInfo> SetNotNullInfo::FormatDeserialize(FormatDeserializer &deserializer) {
392
392
  auto result = duckdb::unique_ptr<SetNotNullInfo>(new SetNotNullInfo());
393
- deserializer.ReadProperty("column_name", result->column_name);
393
+ deserializer.ReadProperty(400, "column_name", result->column_name);
394
394
  return std::move(result);
395
395
  }
396
396
 
397
397
  void TransactionInfo::FormatSerialize(FormatSerializer &serializer) const {
398
398
  ParseInfo::FormatSerialize(serializer);
399
- serializer.WriteProperty("type", type);
399
+ serializer.WriteProperty(200, "type", type);
400
400
  }
401
401
 
402
402
  unique_ptr<ParseInfo> TransactionInfo::FormatDeserialize(FormatDeserializer &deserializer) {
403
403
  auto result = duckdb::unique_ptr<TransactionInfo>(new TransactionInfo());
404
- deserializer.ReadProperty("type", result->type);
404
+ deserializer.ReadProperty(200, "type", result->type);
405
405
  return std::move(result);
406
406
  }
407
407
 
408
408
  void VacuumInfo::FormatSerialize(FormatSerializer &serializer) const {
409
409
  ParseInfo::FormatSerialize(serializer);
410
- serializer.WriteProperty("options", options);
410
+ serializer.WriteProperty(200, "options", options);
411
411
  }
412
412
 
413
413
  unique_ptr<ParseInfo> VacuumInfo::FormatDeserialize(FormatDeserializer &deserializer) {
414
- auto options = deserializer.ReadProperty<VacuumOptions>("options");
414
+ auto options = deserializer.ReadProperty<VacuumOptions>(200, "options");
415
415
  auto result = duckdb::unique_ptr<VacuumInfo>(new VacuumInfo(options));
416
416
  return std::move(result);
417
417
  }