duckdb 0.8.2-dev1435.0 → 0.8.2-dev1493.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 (74) hide show
  1. package/binding.gyp +1 -0
  2. package/package.json +1 -1
  3. package/src/duckdb/src/catalog/catalog_search_path.cpp +5 -4
  4. package/src/duckdb/src/common/radix_partitioning.cpp +1 -1
  5. package/src/duckdb/src/function/table/version/pragma_version.cpp +2 -2
  6. package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic_functions.hpp +3 -1
  7. package/src/duckdb/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp +3 -1
  8. package/src/duckdb/src/include/duckdb/core_functions/aggregate/holistic_functions.hpp +3 -1
  9. package/src/duckdb/src/include/duckdb/core_functions/aggregate/nested_functions.hpp +3 -1
  10. package/src/duckdb/src/include/duckdb/core_functions/aggregate/regression_functions.hpp +3 -1
  11. package/src/duckdb/src/include/duckdb/core_functions/scalar/bit_functions.hpp +3 -1
  12. package/src/duckdb/src/include/duckdb/core_functions/scalar/blob_functions.hpp +3 -1
  13. package/src/duckdb/src/include/duckdb/core_functions/scalar/date_functions.hpp +3 -1
  14. package/src/duckdb/src/include/duckdb/core_functions/scalar/enum_functions.hpp +3 -1
  15. package/src/duckdb/src/include/duckdb/core_functions/scalar/generic_functions.hpp +3 -1
  16. package/src/duckdb/src/include/duckdb/core_functions/scalar/list_functions.hpp +3 -1
  17. package/src/duckdb/src/include/duckdb/core_functions/scalar/map_functions.hpp +3 -1
  18. package/src/duckdb/src/include/duckdb/core_functions/scalar/math_functions.hpp +3 -1
  19. package/src/duckdb/src/include/duckdb/core_functions/scalar/operators_functions.hpp +3 -1
  20. package/src/duckdb/src/include/duckdb/core_functions/scalar/random_functions.hpp +3 -1
  21. package/src/duckdb/src/include/duckdb/core_functions/scalar/string_functions.hpp +3 -1
  22. package/src/duckdb/src/include/duckdb/core_functions/scalar/struct_functions.hpp +3 -1
  23. package/src/duckdb/src/include/duckdb/core_functions/scalar/union_functions.hpp +3 -1
  24. package/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp +3 -0
  25. package/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp +3 -0
  26. package/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp +3 -0
  27. package/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp +3 -0
  28. package/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp +3 -0
  29. package/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp +3 -0
  30. package/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp +1 -0
  31. package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp +3 -0
  32. package/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp +3 -0
  33. package/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp +3 -0
  34. package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp +3 -0
  35. package/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp +1 -0
  36. package/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp +1 -1
  37. package/src/duckdb/src/include/duckdb/parser/tableref/subqueryref.hpp +3 -0
  38. package/src/duckdb/src/parser/expression/between_expression.cpp +3 -15
  39. package/src/duckdb/src/parser/expression/case_expression.cpp +0 -13
  40. package/src/duckdb/src/parser/expression/cast_expression.cpp +3 -14
  41. package/src/duckdb/src/parser/expression/collate_expression.cpp +3 -13
  42. package/src/duckdb/src/parser/expression/columnref_expression.cpp +3 -12
  43. package/src/duckdb/src/parser/expression/comparison_expression.cpp +3 -13
  44. package/src/duckdb/src/parser/expression/conjunction_expression.cpp +0 -12
  45. package/src/duckdb/src/parser/expression/constant_expression.cpp +3 -11
  46. package/src/duckdb/src/parser/expression/default_expression.cpp +0 -4
  47. package/src/duckdb/src/parser/expression/function_expression.cpp +3 -32
  48. package/src/duckdb/src/parser/expression/lambda_expression.cpp +3 -13
  49. package/src/duckdb/src/parser/expression/operator_expression.cpp +0 -12
  50. package/src/duckdb/src/parser/expression/parameter_expression.cpp +0 -12
  51. package/src/duckdb/src/parser/expression/positional_reference_expression.cpp +4 -11
  52. package/src/duckdb/src/parser/expression/star_expression.cpp +0 -19
  53. package/src/duckdb/src/parser/expression/subquery_expression.cpp +0 -18
  54. package/src/duckdb/src/parser/expression/window_expression.cpp +3 -39
  55. package/src/duckdb/src/parser/parsed_expression.cpp +0 -70
  56. package/src/duckdb/src/parser/query_node/cte_node.cpp +0 -17
  57. package/src/duckdb/src/parser/query_node/recursive_cte_node.cpp +0 -19
  58. package/src/duckdb/src/parser/query_node/select_node.cpp +0 -29
  59. package/src/duckdb/src/parser/query_node/set_operation_node.cpp +0 -15
  60. package/src/duckdb/src/parser/query_node.cpp +0 -39
  61. package/src/duckdb/src/parser/result_modifier.cpp +0 -74
  62. package/src/duckdb/src/parser/tableref/basetableref.cpp +0 -19
  63. package/src/duckdb/src/parser/tableref/emptytableref.cpp +0 -4
  64. package/src/duckdb/src/parser/tableref/expressionlistref.cpp +0 -15
  65. package/src/duckdb/src/parser/tableref/joinref.cpp +0 -23
  66. package/src/duckdb/src/parser/tableref/pivotref.cpp +0 -23
  67. package/src/duckdb/src/parser/tableref/subqueryref.cpp +3 -13
  68. package/src/duckdb/src/parser/tableref/table_function.cpp +0 -15
  69. package/src/duckdb/src/parser/tableref.cpp +0 -44
  70. package/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp +340 -0
  71. package/src/duckdb/src/storage/serialization/serialize_query_node.cpp +122 -0
  72. package/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp +86 -0
  73. package/src/duckdb/src/storage/serialization/serialize_tableref.cpp +166 -0
  74. package/src/duckdb/ub_src_storage_serialization.cpp +8 -0
@@ -0,0 +1,86 @@
1
+ //===----------------------------------------------------------------------===//
2
+ // This file is automatically generated by scripts/generate_serialization.py
3
+ // Do not edit this file manually, your changes will be overwritten
4
+ //===----------------------------------------------------------------------===//
5
+
6
+ #include "duckdb/common/serializer/format_serializer.hpp"
7
+ #include "duckdb/common/serializer/format_deserializer.hpp"
8
+ #include "duckdb/parser/result_modifier.hpp"
9
+
10
+ namespace duckdb {
11
+
12
+ void ResultModifier::FormatSerialize(FormatSerializer &serializer) const {
13
+ serializer.WriteProperty("type", type);
14
+ }
15
+
16
+ unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer &deserializer) {
17
+ auto type = deserializer.ReadProperty<ResultModifierType>("type");
18
+ unique_ptr<ResultModifier> result;
19
+ switch (type) {
20
+ case ResultModifierType::DISTINCT_MODIFIER:
21
+ result = DistinctModifier::FormatDeserialize(deserializer);
22
+ break;
23
+ case ResultModifierType::LIMIT_MODIFIER:
24
+ result = LimitModifier::FormatDeserialize(deserializer);
25
+ break;
26
+ case ResultModifierType::LIMIT_PERCENT_MODIFIER:
27
+ result = LimitPercentModifier::FormatDeserialize(deserializer);
28
+ break;
29
+ case ResultModifierType::ORDER_MODIFIER:
30
+ result = OrderModifier::FormatDeserialize(deserializer);
31
+ break;
32
+ default:
33
+ throw SerializationException("Unsupported type for deserialization of ResultModifier!");
34
+ }
35
+ return result;
36
+ }
37
+
38
+ void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
39
+ ResultModifier::FormatSerialize(serializer);
40
+ serializer.WriteOptionalProperty("limit", limit);
41
+ serializer.WriteOptionalProperty("offset", offset);
42
+ }
43
+
44
+ unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
45
+ auto result = duckdb::unique_ptr<LimitModifier>(new LimitModifier());
46
+ deserializer.ReadOptionalProperty("limit", result->limit);
47
+ deserializer.ReadOptionalProperty("offset", result->offset);
48
+ return std::move(result);
49
+ }
50
+
51
+ void DistinctModifier::FormatSerialize(FormatSerializer &serializer) const {
52
+ ResultModifier::FormatSerialize(serializer);
53
+ serializer.WriteProperty("distinct_on_targets", distinct_on_targets);
54
+ }
55
+
56
+ unique_ptr<ResultModifier> DistinctModifier::FormatDeserialize(FormatDeserializer &deserializer) {
57
+ auto result = duckdb::unique_ptr<DistinctModifier>(new DistinctModifier());
58
+ deserializer.ReadProperty("distinct_on_targets", result->distinct_on_targets);
59
+ return std::move(result);
60
+ }
61
+
62
+ void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
63
+ ResultModifier::FormatSerialize(serializer);
64
+ serializer.WriteProperty("orders", orders);
65
+ }
66
+
67
+ unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
68
+ auto result = duckdb::unique_ptr<OrderModifier>(new OrderModifier());
69
+ deserializer.ReadProperty("orders", result->orders);
70
+ return std::move(result);
71
+ }
72
+
73
+ void LimitPercentModifier::FormatSerialize(FormatSerializer &serializer) const {
74
+ ResultModifier::FormatSerialize(serializer);
75
+ serializer.WriteOptionalProperty("limit", limit);
76
+ serializer.WriteOptionalProperty("offset", offset);
77
+ }
78
+
79
+ unique_ptr<ResultModifier> LimitPercentModifier::FormatDeserialize(FormatDeserializer &deserializer) {
80
+ auto result = duckdb::unique_ptr<LimitPercentModifier>(new LimitPercentModifier());
81
+ deserializer.ReadOptionalProperty("limit", result->limit);
82
+ deserializer.ReadOptionalProperty("offset", result->offset);
83
+ return std::move(result);
84
+ }
85
+
86
+ } // namespace duckdb
@@ -0,0 +1,166 @@
1
+ //===----------------------------------------------------------------------===//
2
+ // This file is automatically generated by scripts/generate_serialization.py
3
+ // Do not edit this file manually, your changes will be overwritten
4
+ //===----------------------------------------------------------------------===//
5
+
6
+ #include "duckdb/common/serializer/format_serializer.hpp"
7
+ #include "duckdb/common/serializer/format_deserializer.hpp"
8
+ #include "duckdb/parser/tableref/list.hpp"
9
+
10
+ namespace duckdb {
11
+
12
+ void TableRef::FormatSerialize(FormatSerializer &serializer) const {
13
+ serializer.WriteProperty("type", type);
14
+ serializer.WriteProperty("alias", alias);
15
+ serializer.WriteOptionalProperty("sample", sample);
16
+ }
17
+
18
+ unique_ptr<TableRef> TableRef::FormatDeserialize(FormatDeserializer &deserializer) {
19
+ auto type = deserializer.ReadProperty<TableReferenceType>("type");
20
+ auto alias = deserializer.ReadProperty<string>("alias");
21
+ auto sample = deserializer.ReadOptionalProperty<unique_ptr<SampleOptions>>("sample");
22
+ unique_ptr<TableRef> result;
23
+ switch (type) {
24
+ case TableReferenceType::BASE_TABLE:
25
+ result = BaseTableRef::FormatDeserialize(deserializer);
26
+ break;
27
+ case TableReferenceType::EMPTY:
28
+ result = EmptyTableRef::FormatDeserialize(deserializer);
29
+ break;
30
+ case TableReferenceType::EXPRESSION_LIST:
31
+ result = ExpressionListRef::FormatDeserialize(deserializer);
32
+ break;
33
+ case TableReferenceType::JOIN:
34
+ result = JoinRef::FormatDeserialize(deserializer);
35
+ break;
36
+ case TableReferenceType::PIVOT:
37
+ result = PivotRef::FormatDeserialize(deserializer);
38
+ break;
39
+ case TableReferenceType::SUBQUERY:
40
+ result = SubqueryRef::FormatDeserialize(deserializer);
41
+ break;
42
+ case TableReferenceType::TABLE_FUNCTION:
43
+ result = TableFunctionRef::FormatDeserialize(deserializer);
44
+ break;
45
+ default:
46
+ throw SerializationException("Unsupported type for deserialization of TableRef!");
47
+ }
48
+ result->alias = std::move(alias);
49
+ result->sample = std::move(sample);
50
+ return result;
51
+ }
52
+
53
+ void BaseTableRef::FormatSerialize(FormatSerializer &serializer) const {
54
+ TableRef::FormatSerialize(serializer);
55
+ serializer.WriteProperty("schema_name", schema_name);
56
+ serializer.WriteProperty("table_name", table_name);
57
+ serializer.WriteProperty("column_name_alias", column_name_alias);
58
+ serializer.WriteProperty("catalog_name", catalog_name);
59
+ }
60
+
61
+ unique_ptr<TableRef> BaseTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
62
+ auto result = duckdb::unique_ptr<BaseTableRef>(new BaseTableRef());
63
+ deserializer.ReadProperty("schema_name", result->schema_name);
64
+ deserializer.ReadProperty("table_name", result->table_name);
65
+ deserializer.ReadProperty("column_name_alias", result->column_name_alias);
66
+ deserializer.ReadProperty("catalog_name", result->catalog_name);
67
+ return std::move(result);
68
+ }
69
+
70
+ void JoinRef::FormatSerialize(FormatSerializer &serializer) const {
71
+ TableRef::FormatSerialize(serializer);
72
+ serializer.WriteProperty("left", *left);
73
+ serializer.WriteProperty("right", *right);
74
+ serializer.WriteOptionalProperty("condition", condition);
75
+ serializer.WriteProperty("type", type);
76
+ serializer.WriteProperty("ref_type", ref_type);
77
+ serializer.WriteProperty("using_columns", using_columns);
78
+ }
79
+
80
+ unique_ptr<TableRef> JoinRef::FormatDeserialize(FormatDeserializer &deserializer) {
81
+ auto result = duckdb::unique_ptr<JoinRef>(new JoinRef());
82
+ deserializer.ReadProperty("left", result->left);
83
+ deserializer.ReadProperty("right", result->right);
84
+ deserializer.ReadOptionalProperty("condition", result->condition);
85
+ deserializer.ReadProperty("type", result->type);
86
+ deserializer.ReadProperty("ref_type", result->ref_type);
87
+ deserializer.ReadProperty("using_columns", result->using_columns);
88
+ return std::move(result);
89
+ }
90
+
91
+ void SubqueryRef::FormatSerialize(FormatSerializer &serializer) const {
92
+ TableRef::FormatSerialize(serializer);
93
+ serializer.WriteProperty("subquery", *subquery);
94
+ serializer.WriteProperty("column_name_alias", column_name_alias);
95
+ }
96
+
97
+ unique_ptr<TableRef> SubqueryRef::FormatDeserialize(FormatDeserializer &deserializer) {
98
+ auto result = duckdb::unique_ptr<SubqueryRef>(new SubqueryRef());
99
+ deserializer.ReadProperty("subquery", result->subquery);
100
+ deserializer.ReadProperty("column_name_alias", result->column_name_alias);
101
+ return std::move(result);
102
+ }
103
+
104
+ void TableFunctionRef::FormatSerialize(FormatSerializer &serializer) const {
105
+ TableRef::FormatSerialize(serializer);
106
+ serializer.WriteProperty("function", *function);
107
+ serializer.WriteProperty("alias", alias);
108
+ serializer.WriteProperty("column_name_alias", column_name_alias);
109
+ }
110
+
111
+ unique_ptr<TableRef> TableFunctionRef::FormatDeserialize(FormatDeserializer &deserializer) {
112
+ auto result = duckdb::unique_ptr<TableFunctionRef>(new TableFunctionRef());
113
+ deserializer.ReadProperty("function", result->function);
114
+ deserializer.ReadProperty("alias", result->alias);
115
+ deserializer.ReadProperty("column_name_alias", result->column_name_alias);
116
+ return std::move(result);
117
+ }
118
+
119
+ void EmptyTableRef::FormatSerialize(FormatSerializer &serializer) const {
120
+ TableRef::FormatSerialize(serializer);
121
+ }
122
+
123
+ unique_ptr<TableRef> EmptyTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
124
+ auto result = duckdb::unique_ptr<EmptyTableRef>(new EmptyTableRef());
125
+ return std::move(result);
126
+ }
127
+
128
+ void ExpressionListRef::FormatSerialize(FormatSerializer &serializer) const {
129
+ TableRef::FormatSerialize(serializer);
130
+ serializer.WriteProperty("expected_names", expected_names);
131
+ serializer.WriteProperty("expected_types", expected_types);
132
+ serializer.WriteProperty("values", values);
133
+ }
134
+
135
+ unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &deserializer) {
136
+ auto result = duckdb::unique_ptr<ExpressionListRef>(new ExpressionListRef());
137
+ deserializer.ReadProperty("expected_names", result->expected_names);
138
+ deserializer.ReadProperty("expected_types", result->expected_types);
139
+ deserializer.ReadProperty("values", result->values);
140
+ return std::move(result);
141
+ }
142
+
143
+ void PivotRef::FormatSerialize(FormatSerializer &serializer) const {
144
+ TableRef::FormatSerialize(serializer);
145
+ serializer.WriteProperty("source", *source);
146
+ serializer.WriteProperty("aggregates", aggregates);
147
+ serializer.WriteProperty("unpivot_names", unpivot_names);
148
+ serializer.WriteProperty("pivots", pivots);
149
+ serializer.WriteProperty("groups", groups);
150
+ serializer.WriteProperty("column_name_alias", column_name_alias);
151
+ serializer.WriteProperty("include_nulls", include_nulls);
152
+ }
153
+
154
+ unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &deserializer) {
155
+ auto result = duckdb::unique_ptr<PivotRef>(new PivotRef());
156
+ deserializer.ReadProperty("source", result->source);
157
+ deserializer.ReadProperty("aggregates", result->aggregates);
158
+ deserializer.ReadProperty("unpivot_names", result->unpivot_names);
159
+ deserializer.ReadProperty("pivots", result->pivots);
160
+ deserializer.ReadProperty("groups", result->groups);
161
+ deserializer.ReadProperty("column_name_alias", result->column_name_alias);
162
+ deserializer.ReadProperty("include_nulls", result->include_nulls);
163
+ return std::move(result);
164
+ }
165
+
166
+ } // namespace duckdb
@@ -0,0 +1,8 @@
1
+ #include "src/storage/serialization/serialize_parsed_expression.cpp"
2
+
3
+ #include "src/storage/serialization/serialize_query_node.cpp"
4
+
5
+ #include "src/storage/serialization/serialize_result_modifier.cpp"
6
+
7
+ #include "src/storage/serialization/serialize_tableref.cpp"
8
+