duckdb 0.8.2-dev2700.0 → 0.8.2-dev2842.0

package/src/duckdb/src/planner/operator/logical_get.cpp

@@ -109,6 +109,10 @@ void LogicalGet::ResolveTypes() {
 }
 
 idx_t LogicalGet::EstimateCardinality(ClientContext &context) {
+	// join order optimizer does better cardinality estimation.
+	if (has_estimated_cardinality) {
+		return estimated_cardinality;
+	}
 	if (function.cardinality) {
 		auto node_stats = function.cardinality(context, bind_data.get());
 		if (node_stats && node_stats->has_estimated_cardinality) {
@@ -206,32 +210,32 @@ unique_ptr<LogicalOperator> LogicalGet::Deserialize(LogicalDeserializationState
 
 void LogicalGet::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty("table_index", table_index);
-	serializer.WriteProperty("returned_types", returned_types);
-	serializer.WriteProperty("names", names);
-	serializer.WriteProperty("column_ids", column_ids);
-	serializer.WriteProperty("projection_ids", projection_ids);
-	serializer.WriteProperty("table_filters", table_filters);
+	serializer.WriteProperty(200, "table_index", table_index);
+	serializer.WriteProperty(201, "returned_types", returned_types);
+	serializer.WriteProperty(202, "names", names);
+	serializer.WriteProperty(203, "column_ids", column_ids);
+	serializer.WriteProperty(204, "projection_ids", projection_ids);
+	serializer.WriteProperty(205, "table_filters", table_filters);
 	FunctionSerializer::FormatSerialize(serializer, function, bind_data.get());
 	if (!function.format_serialize) {
 		D_ASSERT(!function.format_deserialize);
 		// no serialize method: serialize input values and named_parameters for rebinding purposes
-		serializer.WriteProperty("parameters", parameters);
-		serializer.WriteProperty("named_parameters", named_parameters);
-		serializer.WriteProperty("input_table_types", input_table_types);
-		serializer.WriteProperty("input_table_names", input_table_names);
+		serializer.WriteProperty(206, "parameters", parameters);
+		serializer.WriteProperty(207, "named_parameters", named_parameters);
+		serializer.WriteProperty(208, "input_table_types", input_table_types);
+		serializer.WriteProperty(209, "input_table_names", input_table_names);
 	}
-	serializer.WriteProperty("projected_input", projected_input);
+	serializer.WriteProperty(210, "projected_input", projected_input);
 }
 
 unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = unique_ptr<LogicalGet>(new LogicalGet());
-	deserializer.ReadProperty("table_index", result->table_index);
-	deserializer.ReadProperty("returned_types", result->returned_types);
-	deserializer.ReadProperty("names", result->names);
-	deserializer.ReadProperty("column_ids", result->column_ids);
-	deserializer.ReadProperty("projection_ids", result->projection_ids);
-	deserializer.ReadProperty("table_filters", result->table_filters);
+	deserializer.ReadProperty(200, "table_index", result->table_index);
+	deserializer.ReadProperty(201, "returned_types", result->returned_types);
+	deserializer.ReadProperty(202, "names", result->names);
+	deserializer.ReadProperty(203, "column_ids", result->column_ids);
+	deserializer.ReadProperty(204, "projection_ids", result->projection_ids);
+	deserializer.ReadProperty(205, "table_filters", result->table_filters);
 	auto entry = FunctionSerializer::FormatDeserializeBase<TableFunction, TableFunctionCatalogEntry>(
 	    deserializer, CatalogType::TABLE_FUNCTION_ENTRY);
 	auto &function = entry.first;
@@ -239,10 +243,10 @@ unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &de
 
 	unique_ptr<FunctionData> bind_data;
 	if (!has_serialize) {
-		deserializer.ReadProperty("parameters", result->parameters);
-		deserializer.ReadProperty("named_parameters", result->named_parameters);
-		deserializer.ReadProperty("input_table_types", result->input_table_types);
-		deserializer.ReadProperty("input_table_names", result->input_table_names);
+		deserializer.ReadProperty(206, "parameters", result->parameters);
+		deserializer.ReadProperty(207, "named_parameters", result->named_parameters);
+		deserializer.ReadProperty(208, "input_table_types", result->input_table_types);
+		deserializer.ReadProperty(209, "input_table_names", result->input_table_names);
 		TableFunctionBindInput input(result->parameters, result->named_parameters, result->input_table_types,
 		                             result->input_table_names, function.function_info.get());
 
@@ -264,7 +268,7 @@ unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &de
 	} else {
 		bind_data = FunctionSerializer::FunctionDeserialize(deserializer, function);
 	}
-	deserializer.ReadProperty("projected_input", result->projected_input);
+	deserializer.ReadProperty(210, "projected_input", result->projected_input);
 	return std::move(result);
 }
 

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

@@ -10,11 +10,11 @@
 namespace duckdb {
 
 void Constraint::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
+	serializer.WriteProperty(100, "type", type);
 }
 
 unique_ptr<Constraint> Constraint::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<ConstraintType>("type");
+	auto type = deserializer.ReadProperty<ConstraintType>(100, "type");
 	unique_ptr<Constraint> result;
 	switch (type) {
 	case ConstraintType::CHECK:
@@ -37,61 +37,61 @@ unique_ptr<Constraint> Constraint::FormatDeserialize(FormatDeserializer &deseria
 
 void CheckConstraint::FormatSerialize(FormatSerializer &serializer) const {
 	Constraint::FormatSerialize(serializer);
-	serializer.WriteProperty("expression", *expression);
+	serializer.WriteProperty(200, "expression", *expression);
 }
 
 unique_ptr<Constraint> CheckConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto expression = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("expression");
+	auto expression = deserializer.ReadProperty<unique_ptr<ParsedExpression>>(200, "expression");
 	auto result = duckdb::unique_ptr<CheckConstraint>(new CheckConstraint(std::move(expression)));
 	return std::move(result);
 }
 
 void ForeignKeyConstraint::FormatSerialize(FormatSerializer &serializer) const {
 	Constraint::FormatSerialize(serializer);
-	serializer.WriteProperty("pk_columns", pk_columns);
-	serializer.WriteProperty("fk_columns", fk_columns);
-	serializer.WriteProperty("fk_type", info.type);
-	serializer.WriteProperty("schema", info.schema);
-	serializer.WriteProperty("table", info.table);
-	serializer.WriteProperty("pk_keys", info.pk_keys);
-	serializer.WriteProperty("fk_keys", info.fk_keys);
+	serializer.WriteProperty(200, "pk_columns", pk_columns);
+	serializer.WriteProperty(201, "fk_columns", fk_columns);
+	serializer.WriteProperty(202, "fk_type", info.type);
+	serializer.WriteProperty(203, "schema", info.schema);
+	serializer.WriteProperty(204, "table", info.table);
+	serializer.WriteProperty(205, "pk_keys", info.pk_keys);
+	serializer.WriteProperty(206, "fk_keys", info.fk_keys);
 }
 
 unique_ptr<Constraint> ForeignKeyConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ForeignKeyConstraint>(new ForeignKeyConstraint());
-	deserializer.ReadProperty("pk_columns", result->pk_columns);
-	deserializer.ReadProperty("fk_columns", result->fk_columns);
-	deserializer.ReadProperty("fk_type", result->info.type);
-	deserializer.ReadProperty("schema", result->info.schema);
-	deserializer.ReadProperty("table", result->info.table);
-	deserializer.ReadProperty("pk_keys", result->info.pk_keys);
-	deserializer.ReadProperty("fk_keys", result->info.fk_keys);
+	deserializer.ReadProperty(200, "pk_columns", result->pk_columns);
+	deserializer.ReadProperty(201, "fk_columns", result->fk_columns);
+	deserializer.ReadProperty(202, "fk_type", result->info.type);
+	deserializer.ReadProperty(203, "schema", result->info.schema);
+	deserializer.ReadProperty(204, "table", result->info.table);
+	deserializer.ReadProperty(205, "pk_keys", result->info.pk_keys);
+	deserializer.ReadProperty(206, "fk_keys", result->info.fk_keys);
 	return std::move(result);
 }
 
 void NotNullConstraint::FormatSerialize(FormatSerializer &serializer) const {
 	Constraint::FormatSerialize(serializer);
-	serializer.WriteProperty("index", index);
+	serializer.WriteProperty(200, "index", index);
 }
 
 unique_ptr<Constraint> NotNullConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto index = deserializer.ReadProperty<LogicalIndex>("index");
+	auto index = deserializer.ReadProperty<LogicalIndex>(200, "index");
 	auto result = duckdb::unique_ptr<NotNullConstraint>(new NotNullConstraint(index));
 	return std::move(result);
 }
 
 void UniqueConstraint::FormatSerialize(FormatSerializer &serializer) const {
 	Constraint::FormatSerialize(serializer);
-	serializer.WriteProperty("is_primary_key", is_primary_key);
-	serializer.WriteProperty("index", index);
-	serializer.WriteProperty("columns", columns);
+	serializer.WriteProperty(200, "is_primary_key", is_primary_key);
+	serializer.WriteProperty(201, "index", index);
+	serializer.WriteProperty(202, "columns", columns);
 }
 
 unique_ptr<Constraint> UniqueConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<UniqueConstraint>(new UniqueConstraint());
-	deserializer.ReadProperty("is_primary_key", result->is_primary_key);
-	deserializer.ReadProperty("index", result->index);
-	deserializer.ReadProperty("columns", result->columns);
+	deserializer.ReadProperty(200, "is_primary_key", result->is_primary_key);
+	deserializer.ReadProperty(201, "index", result->index);
+	deserializer.ReadProperty(202, "columns", result->columns);
 	return std::move(result);
 }
 

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

@@ -17,23 +17,23 @@
 namespace duckdb {
 
 void CreateInfo::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
-	serializer.WriteProperty("catalog", catalog);
-	serializer.WriteProperty("schema", schema);
-	serializer.WriteProperty("temporary", temporary);
-	serializer.WriteProperty("internal", internal);
-	serializer.WriteProperty("on_conflict", on_conflict);
-	serializer.WriteProperty("sql", sql);
+	serializer.WriteProperty(100, "type", type);
+	serializer.WriteProperty(101, "catalog", catalog);
+	serializer.WriteProperty(102, "schema", schema);
+	serializer.WriteProperty(103, "temporary", temporary);
+	serializer.WriteProperty(104, "internal", internal);
+	serializer.WriteProperty(105, "on_conflict", on_conflict);
+	serializer.WriteProperty(106, "sql", sql);
 }
 
 unique_ptr<CreateInfo> CreateInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<CatalogType>("type");
-	auto catalog = deserializer.ReadProperty<string>("catalog");
-	auto schema = deserializer.ReadProperty<string>("schema");
-	auto temporary = deserializer.ReadProperty<bool>("temporary");
-	auto internal = deserializer.ReadProperty<bool>("internal");
-	auto on_conflict = deserializer.ReadProperty<OnCreateConflict>("on_conflict");
-	auto sql = deserializer.ReadProperty<string>("sql");
+	auto type = deserializer.ReadProperty<CatalogType>(100, "type");
+	auto catalog = deserializer.ReadProperty<string>(101, "catalog");
+	auto schema = deserializer.ReadProperty<string>(102, "schema");
+	auto temporary = deserializer.ReadProperty<bool>(103, "temporary");
+	auto internal = deserializer.ReadProperty<bool>(104, "internal");
+	auto on_conflict = deserializer.ReadProperty<OnCreateConflict>(105, "on_conflict");
+	auto sql = deserializer.ReadProperty<string>(106, "sql");
 	unique_ptr<CreateInfo> result;
 	switch (type) {
 	case CatalogType::INDEX_ENTRY:
@@ -74,37 +74,37 @@ unique_ptr<CreateInfo> CreateInfo::FormatDeserialize(FormatDeserializer &deseria
 
 void CreateIndexInfo::FormatSerialize(FormatSerializer &serializer) const {
 	CreateInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("name", index_name);
-	serializer.WriteProperty("table", table);
-	serializer.WriteProperty("index_type", index_type);
-	serializer.WriteProperty("constraint_type", constraint_type);
-	serializer.WriteProperty("parsed_expressions", parsed_expressions);
-	serializer.WriteProperty("names", names);
-	serializer.WriteProperty("column_ids", column_ids);
+	serializer.WriteProperty(200, "name", index_name);
+	serializer.WriteProperty(201, "table", table);
+	serializer.WriteProperty(202, "index_type", index_type);
+	serializer.WriteProperty(203, "constraint_type", constraint_type);
+	serializer.WriteProperty(204, "parsed_expressions", parsed_expressions);
+	serializer.WriteProperty(205, "names", names);
+	serializer.WriteProperty(206, "column_ids", column_ids);
 }
 
 unique_ptr<CreateInfo> CreateIndexInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CreateIndexInfo>(new CreateIndexInfo());
-	deserializer.ReadProperty("name", result->index_name);
-	deserializer.ReadProperty("table", result->table);
-	deserializer.ReadProperty("index_type", result->index_type);
-	deserializer.ReadProperty("constraint_type", result->constraint_type);
-	deserializer.ReadProperty("parsed_expressions", result->parsed_expressions);
-	deserializer.ReadProperty("names", result->names);
-	deserializer.ReadProperty("column_ids", result->column_ids);
+	deserializer.ReadProperty(200, "name", result->index_name);
+	deserializer.ReadProperty(201, "table", result->table);
+	deserializer.ReadProperty(202, "index_type", result->index_type);
+	deserializer.ReadProperty(203, "constraint_type", result->constraint_type);
+	deserializer.ReadProperty(204, "parsed_expressions", result->parsed_expressions);
+	deserializer.ReadProperty(205, "names", result->names);
+	deserializer.ReadProperty(206, "column_ids", result->column_ids);
 	return std::move(result);
 }
 
 void CreateMacroInfo::FormatSerialize(FormatSerializer &serializer) const {
 	CreateInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("name", name);
-	serializer.WriteProperty("function", *function);
+	serializer.WriteProperty(200, "name", name);
+	serializer.WriteProperty(201, "function", *function);
 }
 
 unique_ptr<CreateInfo> CreateMacroInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CreateMacroInfo>(new CreateMacroInfo());
-	deserializer.ReadProperty("name", result->name);
-	deserializer.ReadProperty("function", result->function);
+	deserializer.ReadProperty(200, "name", result->name);
+	deserializer.ReadProperty(201, "function", result->function);
 	return std::move(result);
 }
 
@@ -119,71 +119,71 @@ unique_ptr<CreateInfo> CreateSchemaInfo::FormatDeserialize(FormatDeserializer &d
 
 void CreateSequenceInfo::FormatSerialize(FormatSerializer &serializer) const {
 	CreateInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("name", name);
-	serializer.WriteProperty("usage_count", usage_count);
-	serializer.WriteProperty("increment", increment);
-	serializer.WriteProperty("min_value", min_value);
-	serializer.WriteProperty("max_value", max_value);
-	serializer.WriteProperty("start_value", start_value);
-	serializer.WriteProperty("cycle", cycle);
+	serializer.WriteProperty(200, "name", name);
+	serializer.WriteProperty(201, "usage_count", usage_count);
+	serializer.WriteProperty(202, "increment", increment);
+	serializer.WriteProperty(203, "min_value", min_value);
+	serializer.WriteProperty(204, "max_value", max_value);
+	serializer.WriteProperty(205, "start_value", start_value);
+	serializer.WriteProperty(206, "cycle", cycle);
 }
 
 unique_ptr<CreateInfo> CreateSequenceInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CreateSequenceInfo>(new CreateSequenceInfo());
-	deserializer.ReadProperty("name", result->name);
-	deserializer.ReadProperty("usage_count", result->usage_count);
-	deserializer.ReadProperty("increment", result->increment);
-	deserializer.ReadProperty("min_value", result->min_value);
-	deserializer.ReadProperty("max_value", result->max_value);
-	deserializer.ReadProperty("start_value", result->start_value);
-	deserializer.ReadProperty("cycle", result->cycle);
+	deserializer.ReadProperty(200, "name", result->name);
+	deserializer.ReadProperty(201, "usage_count", result->usage_count);
+	deserializer.ReadProperty(202, "increment", result->increment);
+	deserializer.ReadProperty(203, "min_value", result->min_value);
+	deserializer.ReadProperty(204, "max_value", result->max_value);
+	deserializer.ReadProperty(205, "start_value", result->start_value);
+	deserializer.ReadProperty(206, "cycle", result->cycle);
 	return std::move(result);
 }
 
 void CreateTableInfo::FormatSerialize(FormatSerializer &serializer) const {
 	CreateInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("table", table);
-	serializer.WriteProperty("columns", columns);
-	serializer.WriteProperty("constraints", constraints);
-	serializer.WriteOptionalProperty("query", query);
+	serializer.WriteProperty(200, "table", table);
+	serializer.WriteProperty(201, "columns", columns);
+	serializer.WriteProperty(202, "constraints", constraints);
+	serializer.WriteOptionalProperty(203, "query", query);
 }
 
 unique_ptr<CreateInfo> CreateTableInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CreateTableInfo>(new CreateTableInfo());
-	deserializer.ReadProperty("table", result->table);
-	deserializer.ReadProperty("columns", result->columns);
-	deserializer.ReadProperty("constraints", result->constraints);
-	deserializer.ReadOptionalProperty("query", result->query);
+	deserializer.ReadProperty(200, "table", result->table);
+	deserializer.ReadProperty(201, "columns", result->columns);
+	deserializer.ReadProperty(202, "constraints", result->constraints);
+	deserializer.ReadOptionalProperty(203, "query", result->query);
 	return std::move(result);
 }
 
 void CreateTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	CreateInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("name", name);
-	serializer.WriteProperty("logical_type", type);
+	serializer.WriteProperty(200, "name", name);
+	serializer.WriteProperty(201, "logical_type", type);
 }
 
 unique_ptr<CreateInfo> CreateTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CreateTypeInfo>(new CreateTypeInfo());
-	deserializer.ReadProperty("name", result->name);
-	deserializer.ReadProperty("logical_type", result->type);
+	deserializer.ReadProperty(200, "name", result->name);
+	deserializer.ReadProperty(201, "logical_type", result->type);
 	return std::move(result);
 }
 
 void CreateViewInfo::FormatSerialize(FormatSerializer &serializer) const {
 	CreateInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("view_name", view_name);
-	serializer.WriteProperty("aliases", aliases);
-	serializer.WriteProperty("types", types);
-	serializer.WriteOptionalProperty("query", query);
+	serializer.WriteProperty(200, "view_name", view_name);
+	serializer.WriteProperty(201, "aliases", aliases);
+	serializer.WriteProperty(202, "types", types);
+	serializer.WriteOptionalProperty(203, "query", query);
 }
 
 unique_ptr<CreateInfo> CreateViewInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CreateViewInfo>(new CreateViewInfo());
-	deserializer.ReadProperty("view_name", result->view_name);
-	deserializer.ReadProperty("aliases", result->aliases);
-	deserializer.ReadProperty("types", result->types);
-	deserializer.ReadOptionalProperty("query", result->query);
+	deserializer.ReadProperty(200, "view_name", result->view_name);
+	deserializer.ReadProperty(201, "aliases", result->aliases);
+	deserializer.ReadProperty(202, "types", result->types);
+	deserializer.ReadOptionalProperty(203, "query", result->query);
 	return std::move(result);
 }