duckdb 0.8.2-dev2809.0 → 0.8.2-dev2850.0

package/src/duckdb/src/storage/serialization/serialize_table_filter.cpp

@@ -13,11 +13,11 @@
 namespace duckdb {
 
 void TableFilter::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("filter_type", filter_type);
+	serializer.WriteProperty(100, "filter_type", filter_type);
 }
 
 unique_ptr<TableFilter> TableFilter::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto filter_type = deserializer.ReadProperty<TableFilterType>("filter_type");
+	auto filter_type = deserializer.ReadProperty<TableFilterType>(100, "filter_type");
 	unique_ptr<TableFilter> result;
 	switch (filter_type) {
 	case TableFilterType::CONJUNCTION_AND:
@@ -43,35 +43,35 @@ unique_ptr<TableFilter> TableFilter::FormatDeserialize(FormatDeserializer &deser
 
 void ConjunctionAndFilter::FormatSerialize(FormatSerializer &serializer) const {
 	TableFilter::FormatSerialize(serializer);
-	serializer.WriteProperty("child_filters", child_filters);
+	serializer.WriteProperty(200, "child_filters", child_filters);
 }
 
 unique_ptr<TableFilter> ConjunctionAndFilter::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ConjunctionAndFilter>(new ConjunctionAndFilter());
-	deserializer.ReadProperty("child_filters", result->child_filters);
+	deserializer.ReadProperty(200, "child_filters", result->child_filters);
 	return std::move(result);
 }
 
 void ConjunctionOrFilter::FormatSerialize(FormatSerializer &serializer) const {
 	TableFilter::FormatSerialize(serializer);
-	serializer.WriteProperty("child_filters", child_filters);
+	serializer.WriteProperty(200, "child_filters", child_filters);
 }
 
 unique_ptr<TableFilter> ConjunctionOrFilter::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ConjunctionOrFilter>(new ConjunctionOrFilter());
-	deserializer.ReadProperty("child_filters", result->child_filters);
+	deserializer.ReadProperty(200, "child_filters", result->child_filters);
 	return std::move(result);
 }
 
 void ConstantFilter::FormatSerialize(FormatSerializer &serializer) const {
 	TableFilter::FormatSerialize(serializer);
-	serializer.WriteProperty("comparison_type", comparison_type);
-	serializer.WriteProperty("constant", constant);
+	serializer.WriteProperty(200, "comparison_type", comparison_type);
+	serializer.WriteProperty(201, "constant", constant);
 }
 
 unique_ptr<TableFilter> ConstantFilter::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto comparison_type = deserializer.ReadProperty<ExpressionType>("comparison_type");
-	auto constant = deserializer.ReadProperty<Value>("constant");
+	auto comparison_type = deserializer.ReadProperty<ExpressionType>(200, "comparison_type");
+	auto constant = deserializer.ReadProperty<Value>(201, "constant");
 	auto result = duckdb::unique_ptr<ConstantFilter>(new ConstantFilter(comparison_type, constant));
 	return std::move(result);
 }

package/src/duckdb/src/storage/serialization/serialize_tableref.cpp

@@ -10,15 +10,15 @@
 namespace duckdb {
 
 void TableRef::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
-	serializer.WriteProperty("alias", alias);
-	serializer.WriteOptionalProperty("sample", sample);
+	serializer.WriteProperty(100, "type", type);
+	serializer.WriteProperty(101, "alias", alias);
+	serializer.WriteOptionalProperty(102, "sample", sample);
 }
 
 unique_ptr<TableRef> TableRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<TableReferenceType>("type");
-	auto alias = deserializer.ReadProperty<string>("alias");
-	auto sample = deserializer.ReadOptionalProperty<unique_ptr<SampleOptions>>("sample");
+	auto type = deserializer.ReadProperty<TableReferenceType>(100, "type");
+	auto alias = deserializer.ReadProperty<string>(101, "alias");
+	auto sample = deserializer.ReadOptionalProperty<unique_ptr<SampleOptions>>(102, "sample");
 	unique_ptr<TableRef> result;
 	switch (type) {
 	case TableReferenceType::BASE_TABLE:
@@ -52,18 +52,18 @@ unique_ptr<TableRef> TableRef::FormatDeserialize(FormatDeserializer &deserialize
 
 void BaseTableRef::FormatSerialize(FormatSerializer &serializer) const {
 	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("schema_name", schema_name);
-	serializer.WriteProperty("table_name", table_name);
-	serializer.WriteProperty("column_name_alias", column_name_alias);
-	serializer.WriteProperty("catalog_name", catalog_name);
+	serializer.WriteProperty(200, "schema_name", schema_name);
+	serializer.WriteProperty(201, "table_name", table_name);
+	serializer.WriteProperty(202, "column_name_alias", column_name_alias);
+	serializer.WriteProperty(203, "catalog_name", catalog_name);
 }
 
 unique_ptr<TableRef> BaseTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<BaseTableRef>(new BaseTableRef());
-	deserializer.ReadProperty("schema_name", result->schema_name);
-	deserializer.ReadProperty("table_name", result->table_name);
-	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
-	deserializer.ReadProperty("catalog_name", result->catalog_name);
+	deserializer.ReadProperty(200, "schema_name", result->schema_name);
+	deserializer.ReadProperty(201, "table_name", result->table_name);
+	deserializer.ReadProperty(202, "column_name_alias", result->column_name_alias);
+	deserializer.ReadProperty(203, "catalog_name", result->catalog_name);
 	return std::move(result);
 }
 
@@ -78,86 +78,86 @@ unique_ptr<TableRef> EmptyTableRef::FormatDeserialize(FormatDeserializer &deseri
 
 void ExpressionListRef::FormatSerialize(FormatSerializer &serializer) const {
 	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("expected_names", expected_names);
-	serializer.WriteProperty("expected_types", expected_types);
-	serializer.WriteProperty("values", values);
+	serializer.WriteProperty(200, "expected_names", expected_names);
+	serializer.WriteProperty(201, "expected_types", expected_types);
+	serializer.WriteProperty(202, "values", values);
 }
 
 unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ExpressionListRef>(new ExpressionListRef());
-	deserializer.ReadProperty("expected_names", result->expected_names);
-	deserializer.ReadProperty("expected_types", result->expected_types);
-	deserializer.ReadProperty("values", result->values);
+	deserializer.ReadProperty(200, "expected_names", result->expected_names);
+	deserializer.ReadProperty(201, "expected_types", result->expected_types);
+	deserializer.ReadProperty(202, "values", result->values);
 	return std::move(result);
 }
 
 void JoinRef::FormatSerialize(FormatSerializer &serializer) const {
 	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("left", *left);
-	serializer.WriteProperty("right", *right);
-	serializer.WriteOptionalProperty("condition", condition);
-	serializer.WriteProperty("join_type", type);
-	serializer.WriteProperty("ref_type", ref_type);
-	serializer.WriteProperty("using_columns", using_columns);
+	serializer.WriteProperty(200, "left", *left);
+	serializer.WriteProperty(201, "right", *right);
+	serializer.WriteOptionalProperty(202, "condition", condition);
+	serializer.WriteProperty(203, "join_type", type);
+	serializer.WriteProperty(204, "ref_type", ref_type);
+	serializer.WriteProperty(205, "using_columns", using_columns);
 }
 
 unique_ptr<TableRef> JoinRef::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<JoinRef>(new JoinRef());
-	deserializer.ReadProperty("left", result->left);
-	deserializer.ReadProperty("right", result->right);
-	deserializer.ReadOptionalProperty("condition", result->condition);
-	deserializer.ReadProperty("join_type", result->type);
-	deserializer.ReadProperty("ref_type", result->ref_type);
-	deserializer.ReadProperty("using_columns", result->using_columns);
+	deserializer.ReadProperty(200, "left", result->left);
+	deserializer.ReadProperty(201, "right", result->right);
+	deserializer.ReadOptionalProperty(202, "condition", result->condition);
+	deserializer.ReadProperty(203, "join_type", result->type);
+	deserializer.ReadProperty(204, "ref_type", result->ref_type);
+	deserializer.ReadProperty(205, "using_columns", result->using_columns);
 	return std::move(result);
 }
 
 void PivotRef::FormatSerialize(FormatSerializer &serializer) const {
 	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("source", *source);
-	serializer.WriteProperty("aggregates", aggregates);
-	serializer.WriteProperty("unpivot_names", unpivot_names);
-	serializer.WriteProperty("pivots", pivots);
-	serializer.WriteProperty("groups", groups);
-	serializer.WriteProperty("column_name_alias", column_name_alias);
-	serializer.WriteProperty("include_nulls", include_nulls);
+	serializer.WriteProperty(200, "source", *source);
+	serializer.WriteProperty(201, "aggregates", aggregates);
+	serializer.WriteProperty(202, "unpivot_names", unpivot_names);
+	serializer.WriteProperty(203, "pivots", pivots);
+	serializer.WriteProperty(204, "groups", groups);
+	serializer.WriteProperty(205, "column_name_alias", column_name_alias);
+	serializer.WriteProperty(206, "include_nulls", include_nulls);
 }
 
 unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<PivotRef>(new PivotRef());
-	deserializer.ReadProperty("source", result->source);
-	deserializer.ReadProperty("aggregates", result->aggregates);
-	deserializer.ReadProperty("unpivot_names", result->unpivot_names);
-	deserializer.ReadProperty("pivots", result->pivots);
-	deserializer.ReadProperty("groups", result->groups);
-	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
-	deserializer.ReadProperty("include_nulls", result->include_nulls);
+	deserializer.ReadProperty(200, "source", result->source);
+	deserializer.ReadProperty(201, "aggregates", result->aggregates);
+	deserializer.ReadProperty(202, "unpivot_names", result->unpivot_names);
+	deserializer.ReadProperty(203, "pivots", result->pivots);
+	deserializer.ReadProperty(204, "groups", result->groups);
+	deserializer.ReadProperty(205, "column_name_alias", result->column_name_alias);
+	deserializer.ReadProperty(206, "include_nulls", result->include_nulls);
 	return std::move(result);
 }
 
 void SubqueryRef::FormatSerialize(FormatSerializer &serializer) const {
 	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("subquery", *subquery);
-	serializer.WriteProperty("column_name_alias", column_name_alias);
+	serializer.WriteProperty(200, "subquery", *subquery);
+	serializer.WriteProperty(201, "column_name_alias", column_name_alias);
 }
 
 unique_ptr<TableRef> SubqueryRef::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SubqueryRef>(new SubqueryRef());
-	deserializer.ReadProperty("subquery", result->subquery);
-	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
+	deserializer.ReadProperty(200, "subquery", result->subquery);
+	deserializer.ReadProperty(201, "column_name_alias", result->column_name_alias);
 	return std::move(result);
 }
 
 void TableFunctionRef::FormatSerialize(FormatSerializer &serializer) const {
 	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("function", *function);
-	serializer.WriteProperty("column_name_alias", column_name_alias);
+	serializer.WriteProperty(200, "function", *function);
+	serializer.WriteProperty(201, "column_name_alias", column_name_alias);
 }
 
 unique_ptr<TableRef> TableFunctionRef::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<TableFunctionRef>(new TableFunctionRef());
-	deserializer.ReadProperty("function", result->function);
-	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
+	deserializer.ReadProperty(200, "function", result->function);
+	deserializer.ReadProperty(201, "column_name_alias", result->column_name_alias);
 	return std::move(result);
 }
 

package/src/duckdb/src/storage/serialization/serialize_types.cpp

@@ -10,13 +10,13 @@
 namespace duckdb {
 
 void ExtraTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
-	serializer.WriteProperty("alias", alias);
+	serializer.WriteProperty(100, "type", type);
+	serializer.WriteProperty(101, "alias", alias);
 }
 
 shared_ptr<ExtraTypeInfo> ExtraTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<ExtraTypeInfoType>("type");
-	auto alias = deserializer.ReadProperty<string>("alias");
+	auto type = deserializer.ReadProperty<ExtraTypeInfoType>(100, "type");
+	auto alias = deserializer.ReadProperty<string>(101, "alias");
 	shared_ptr<ExtraTypeInfo> result;
 	switch (type) {
 	case ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO:
@@ -54,73 +54,73 @@ shared_ptr<ExtraTypeInfo> ExtraTypeInfo::FormatDeserialize(FormatDeserializer &d
 
 void AggregateStateTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("function_name", state_type.function_name);
-	serializer.WriteProperty("return_type", state_type.return_type);
-	serializer.WriteProperty("bound_argument_types", state_type.bound_argument_types);
+	serializer.WriteProperty(200, "function_name", state_type.function_name);
+	serializer.WriteProperty(201, "return_type", state_type.return_type);
+	serializer.WriteProperty(202, "bound_argument_types", state_type.bound_argument_types);
 }
 
 shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::shared_ptr<AggregateStateTypeInfo>(new AggregateStateTypeInfo());
-	deserializer.ReadProperty("function_name", result->state_type.function_name);
-	deserializer.ReadProperty("return_type", result->state_type.return_type);
-	deserializer.ReadProperty("bound_argument_types", result->state_type.bound_argument_types);
+	deserializer.ReadProperty(200, "function_name", result->state_type.function_name);
+	deserializer.ReadProperty(201, "return_type", result->state_type.return_type);
+	deserializer.ReadProperty(202, "bound_argument_types", result->state_type.bound_argument_types);
 	return std::move(result);
 }
 
 void DecimalTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("width", width);
-	serializer.WriteProperty("scale", scale);
+	serializer.WriteProperty(200, "width", width);
+	serializer.WriteProperty(201, "scale", scale);
 }
 
 shared_ptr<ExtraTypeInfo> DecimalTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::shared_ptr<DecimalTypeInfo>(new DecimalTypeInfo());
-	deserializer.ReadProperty("width", result->width);
-	deserializer.ReadProperty("scale", result->scale);
+	deserializer.ReadProperty(200, "width", result->width);
+	deserializer.ReadProperty(201, "scale", result->scale);
 	return std::move(result);
 }
 
 void ListTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("child_type", child_type);
+	serializer.WriteProperty(200, "child_type", child_type);
 }
 
 shared_ptr<ExtraTypeInfo> ListTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::shared_ptr<ListTypeInfo>(new ListTypeInfo());
-	deserializer.ReadProperty("child_type", result->child_type);
+	deserializer.ReadProperty(200, "child_type", result->child_type);
 	return std::move(result);
 }
 
 void StringTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("collation", collation);
+	serializer.WriteProperty(200, "collation", collation);
 }
 
 shared_ptr<ExtraTypeInfo> StringTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::shared_ptr<StringTypeInfo>(new StringTypeInfo());
-	deserializer.ReadProperty("collation", result->collation);
+	deserializer.ReadProperty(200, "collation", result->collation);
 	return std::move(result);
 }
 
 void StructTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("child_types", child_types);
+	serializer.WriteProperty(200, "child_types", child_types);
 }
 
 shared_ptr<ExtraTypeInfo> StructTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::shared_ptr<StructTypeInfo>(new StructTypeInfo());
-	deserializer.ReadProperty("child_types", result->child_types);
+	deserializer.ReadProperty(200, "child_types", result->child_types);
 	return std::move(result);
 }
 
 void UserTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("user_type_name", user_type_name);
+	serializer.WriteProperty(200, "user_type_name", user_type_name);
 }
 
 shared_ptr<ExtraTypeInfo> UserTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::shared_ptr<UserTypeInfo>(new UserTypeInfo());
-	deserializer.ReadProperty("user_type_name", result->user_type_name);
+	deserializer.ReadProperty(200, "user_type_name", result->user_type_name);
 	return std::move(result);
 }
 

package/src/duckdb/src/storage/table/update_segment.cpp

@@ -427,7 +427,7 @@ void UpdateSegment::FetchRow(TransactionData transaction, idx_t row_id, Vector &
 	if (!root->info[vector_index]) {
 		return;
 	}
-	idx_t row_in_vector = row_id - vector_index * STANDARD_VECTOR_SIZE;
+	idx_t row_in_vector = (row_id - column_data.start) - vector_index * STANDARD_VECTOR_SIZE;
 	fetch_row_function(transaction.start_time, transaction.transaction_id, root->info[vector_index]->info.get(),
 	                   row_in_vector, result, result_idx);
 }