duckdb 0.8.2-dev1862.0 → 0.8.2-dev2044.0

package/src/duckdb/src/parser/column_definition.cpp

@@ -13,28 +13,14 @@ ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p)
 
 ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p, unique_ptr<ParsedExpression> expression,
                                    TableColumnType category)
-    : name(std::move(name_p)), type(std::move(type_p)), category(category) {
-	switch (category) {
-	case TableColumnType::STANDARD: {
-		default_value = std::move(expression);
-		break;
-	}
-	case TableColumnType::GENERATED: {
-		generated_expression = std::move(expression);
-		break;
-	}
-	default: {
-		throw InternalException("Type not implemented for TableColumnType");
-	}
-	}
+    : name(std::move(name_p)), type(std::move(type_p)), category(category), expression(std::move(expression)) {
 }
 
 ColumnDefinition ColumnDefinition::Copy() const {
 	ColumnDefinition copy(name, type);
 	copy.oid = oid;
 	copy.storage_oid = storage_oid;
-	copy.SetDefaultValue(default_value ? default_value->Copy() : nullptr);
-	copy.generated_expression = generated_expression ? generated_expression->Copy() : nullptr;
+	copy.expression = expression ? expression->Copy() : nullptr;
 	copy.compression_type = compression_type;
 	copy.category = category;
 	return copy;
@@ -44,11 +30,7 @@ void ColumnDefinition::Serialize(Serializer &serializer) const {
 	FieldWriter writer(serializer);
 	writer.WriteString(name);
 	writer.WriteSerializable(type);
-	if (Generated()) {
-		writer.WriteOptional(generated_expression);
-	} else {
-		writer.WriteOptional(default_value);
-	}
+	writer.WriteOptional(expression);
 	writer.WriteField<TableColumnType>(category);
 	writer.WriteField<duckdb::CompressionType>(compression_type);
 	writer.Finalize();
@@ -69,11 +51,17 @@ ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
 }
 
 const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {
-	return default_value;
+	if (Generated()) {
+		throw InternalException("Calling DefaultValue() on a generated column");
+	}
+	return expression;
 }
 
 void ColumnDefinition::SetDefaultValue(unique_ptr<ParsedExpression> default_value) {
-	this->default_value = std::move(default_value);
+	if (Generated()) {
+		throw InternalException("Calling SetDefaultValue() on a generated column");
+	}
+	this->expression = std::move(default_value);
 }
 
 const LogicalType &ColumnDefinition::Type() const {
@@ -168,7 +156,7 @@ static void InnerGetListOfDependencies(ParsedExpression &expr, vector<string> &d
 
 void ColumnDefinition::GetListOfDependencies(vector<string> &dependencies) const {
 	D_ASSERT(Generated());
-	InnerGetListOfDependencies(*generated_expression, dependencies);
+	InnerGetListOfDependencies(*expression, dependencies);
 }
 
 string ColumnDefinition::GetName() const {
@@ -179,28 +167,28 @@ LogicalType ColumnDefinition::GetType() const {
 	return type;
 }
 
-void ColumnDefinition::SetGeneratedExpression(unique_ptr<ParsedExpression> expression) {
+void ColumnDefinition::SetGeneratedExpression(unique_ptr<ParsedExpression> new_expr) {
 	category = TableColumnType::GENERATED;
 
-	if (expression->HasSubquery()) {
+	if (new_expr->HasSubquery()) {
 		throw ParserException("Expression of generated column \"%s\" contains a subquery, which isn't allowed", name);
 	}
 
-	VerifyColumnRefs(*expression);
+	VerifyColumnRefs(*new_expr);
 	if (type.id() == LogicalTypeId::ANY) {
-		generated_expression = std::move(expression);
+		expression = std::move(new_expr);
 		return;
 	}
 	// Always wrap the expression in a cast, that way we can always update the cast when we change the type
 	// Except if the type is LogicalType::ANY (no type specified)
-	generated_expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(expression));
+	expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(new_expr));
 }
 
 void ColumnDefinition::ChangeGeneratedExpressionType(const LogicalType &type) {
 	D_ASSERT(Generated());
 	// First time the type is set, add a cast around the expression
 	D_ASSERT(this->type.id() == LogicalTypeId::ANY);
-	generated_expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(generated_expression));
+	expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(expression));
 	// Every generated expression should be wrapped in a cast on creation
 	// D_ASSERT(generated_expression->type == ExpressionType::OPERATOR_CAST);
 	// auto &cast_expr = generated_expression->Cast<CastExpression>();
@@ -210,12 +198,12 @@ void ColumnDefinition::ChangeGeneratedExpressionType(const LogicalType &type) {
 
 const ParsedExpression &ColumnDefinition::GeneratedExpression() const {
 	D_ASSERT(Generated());
-	return *generated_expression;
+	return *expression;
 }
 
 ParsedExpression &ColumnDefinition::GeneratedExpressionMutable() {
 	D_ASSERT(Generated());
-	return *generated_expression;
+	return *expression;
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/column_list.cpp

@@ -6,6 +6,14 @@ namespace duckdb {
 
 ColumnList::ColumnList(bool allow_duplicate_names) : allow_duplicate_names(allow_duplicate_names) {
 }
+
+ColumnList::ColumnList(vector<ColumnDefinition> columns, bool allow_duplicate_names)
+    : allow_duplicate_names(allow_duplicate_names) {
+	for (auto &col : columns) {
+		AddColumn(std::move(col));
+	}
+}
+
 void ColumnList::AddColumn(ColumnDefinition column) {
 	auto oid = columns.size();
 	if (!column.Generated()) {

package/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp

@@ -6,6 +6,9 @@
 
 namespace duckdb {
 
+ForeignKeyConstraint::ForeignKeyConstraint() : Constraint(ConstraintType::FOREIGN_KEY) {
+}
+
 ForeignKeyConstraint::ForeignKeyConstraint(vector<string> pk_columns, vector<string> fk_columns, ForeignKeyInfo info)
     : Constraint(ConstraintType::FOREIGN_KEY), pk_columns(std::move(pk_columns)), fk_columns(std::move(fk_columns)),
       info(std::move(info)) {

package/src/duckdb/src/parser/constraints/unique_constraint.cpp

@@ -6,6 +6,9 @@
 
 namespace duckdb {
 
+UniqueConstraint::UniqueConstraint() : Constraint(ConstraintType::UNIQUE), index(DConstants::INVALID_INDEX) {
+}
+
 UniqueConstraint::UniqueConstraint(LogicalIndex index, bool is_primary_key)
     : Constraint(ConstraintType::UNIQUE), index(index), is_primary_key(is_primary_key) {
 }

package/src/duckdb/src/parser/expression/case_expression.cpp

@@ -8,18 +8,6 @@
 
 namespace duckdb {
 
-void CaseCheck::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("when_expr", when_expr);
-	serializer.WriteProperty("then_expr", then_expr);
-}
-
-CaseCheck CaseCheck::FormatDeserialize(FormatDeserializer &deserializer) {
-	CaseCheck check;
-	deserializer.ReadProperty("when_expr", check.when_expr);
-	deserializer.ReadProperty("then_expr", check.then_expr);
-	return check;
-}
-
 CaseExpression::CaseExpression() : ParsedExpression(ExpressionType::CASE_EXPR, ExpressionClass::CASE) {
 }
 

package/src/duckdb/src/parser/parsed_data/alter_info.cpp

@@ -8,8 +8,11 @@
 namespace duckdb {
 
 AlterInfo::AlterInfo(AlterType type, string catalog_p, string schema_p, string name_p, OnEntryNotFound if_not_found)
-    : type(type), if_not_found(if_not_found), catalog(std::move(catalog_p)), schema(std::move(schema_p)),
-      name(std::move(name_p)), allow_internal(false) {
+    : ParseInfo(TYPE), type(type), if_not_found(if_not_found), catalog(std::move(catalog_p)),
+      schema(std::move(schema_p)), name(std::move(name_p)), allow_internal(false) {
+}
+
+AlterInfo::AlterInfo(AlterType type) : ParseInfo(TYPE), type(type) {
 }
 
 AlterInfo::~AlterInfo() {

package/src/duckdb/src/parser/parsed_data/alter_table_info.cpp

@@ -33,6 +33,9 @@ void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
 //===--------------------------------------------------------------------===//
 // AlterTableInfo
 //===--------------------------------------------------------------------===//
+AlterTableInfo::AlterTableInfo(AlterTableType type) : AlterInfo(AlterType::ALTER_TABLE), alter_table_type(type) {
+}
+
 AlterTableInfo::AlterTableInfo(AlterTableType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_TABLE, std::move(data.catalog), std::move(data.schema), std::move(data.name),
                 data.if_not_found),
@@ -94,6 +97,10 @@ RenameColumnInfo::RenameColumnInfo(AlterEntryData data, string old_name_p, strin
     : AlterTableInfo(AlterTableType::RENAME_COLUMN, std::move(data)), old_name(std::move(old_name_p)),
       new_name(std::move(new_name_p)) {
 }
+
+RenameColumnInfo::RenameColumnInfo() : AlterTableInfo(AlterTableType::RENAME_COLUMN) {
+}
+
 RenameColumnInfo::~RenameColumnInfo() {
 }
 
@@ -115,9 +122,13 @@ unique_ptr<AlterInfo> RenameColumnInfo::Deserialize(FieldReader &reader, AlterEn
 //===--------------------------------------------------------------------===//
 // RenameTableInfo
 //===--------------------------------------------------------------------===//
+RenameTableInfo::RenameTableInfo() : AlterTableInfo(AlterTableType::RENAME_TABLE) {
+}
+
 RenameTableInfo::RenameTableInfo(AlterEntryData data, string new_name_p)
     : AlterTableInfo(AlterTableType::RENAME_TABLE, std::move(data)), new_table_name(std::move(new_name_p)) {
 }
+
 RenameTableInfo::~RenameTableInfo() {
 }
 
@@ -137,6 +148,10 @@ unique_ptr<AlterInfo> RenameTableInfo::Deserialize(FieldReader &reader, AlterEnt
 //===--------------------------------------------------------------------===//
 // AddColumnInfo
 //===--------------------------------------------------------------------===//
+AddColumnInfo::AddColumnInfo(ColumnDefinition new_column_p)
+    : AlterTableInfo(AlterTableType::ADD_COLUMN), new_column(std::move(new_column_p)) {
+}
+
 AddColumnInfo::AddColumnInfo(AlterEntryData data, ColumnDefinition new_column, bool if_column_not_exists)
     : AlterTableInfo(AlterTableType::ADD_COLUMN, std::move(data)), new_column(std::move(new_column)),
       if_column_not_exists(if_column_not_exists) {
@@ -163,6 +178,9 @@ unique_ptr<AlterInfo> AddColumnInfo::Deserialize(FieldReader &reader, AlterEntry
 //===--------------------------------------------------------------------===//
 // RemoveColumnInfo
 //===--------------------------------------------------------------------===//
+RemoveColumnInfo::RemoveColumnInfo() : AlterTableInfo(AlterTableType::REMOVE_COLUMN) {
+}
+
 RemoveColumnInfo::RemoveColumnInfo(AlterEntryData data, string removed_column, bool if_column_exists, bool cascade)
     : AlterTableInfo(AlterTableType::REMOVE_COLUMN, std::move(data)), removed_column(std::move(removed_column)),
       if_column_exists(if_column_exists), cascade(cascade) {
@@ -190,6 +208,9 @@ unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, AlterEn
 //===--------------------------------------------------------------------===//
 // ChangeColumnTypeInfo
 //===--------------------------------------------------------------------===//
+ChangeColumnTypeInfo::ChangeColumnTypeInfo() : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE) {
+}
+
 ChangeColumnTypeInfo::ChangeColumnTypeInfo(AlterEntryData data, string column_name, LogicalType target_type,
                                            unique_ptr<ParsedExpression> expression)
     : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, std::move(data)), column_name(std::move(column_name)),
@@ -220,6 +241,9 @@ unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(FieldReader &reader, Alt
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//
+SetDefaultInfo::SetDefaultInfo() : AlterTableInfo(AlterTableType::SET_DEFAULT) {
+}
+
 SetDefaultInfo::SetDefaultInfo(AlterEntryData data, string column_name_p, unique_ptr<ParsedExpression> new_default)
     : AlterTableInfo(AlterTableType::SET_DEFAULT, std::move(data)), column_name(std::move(column_name_p)),
       expression(std::move(new_default)) {
@@ -246,6 +270,9 @@ unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(FieldReader &reader, AlterEntr
 //===--------------------------------------------------------------------===//
 // SetNotNullInfo
 //===--------------------------------------------------------------------===//
+SetNotNullInfo::SetNotNullInfo() : AlterTableInfo(AlterTableType::SET_NOT_NULL) {
+}
+
 SetNotNullInfo::SetNotNullInfo(AlterEntryData data, string column_name_p)
     : AlterTableInfo(AlterTableType::SET_NOT_NULL, std::move(data)), column_name(std::move(column_name_p)) {
 }
@@ -268,6 +295,9 @@ unique_ptr<AlterInfo> SetNotNullInfo::Deserialize(FieldReader &reader, AlterEntr
 //===--------------------------------------------------------------------===//
 // DropNotNullInfo
 //===--------------------------------------------------------------------===//
+DropNotNullInfo::DropNotNullInfo() : AlterTableInfo(AlterTableType::DROP_NOT_NULL) {
+}
+
 DropNotNullInfo::DropNotNullInfo(AlterEntryData data, string column_name_p)
     : AlterTableInfo(AlterTableType::DROP_NOT_NULL, std::move(data)), column_name(std::move(column_name_p)) {
 }
@@ -290,6 +320,9 @@ unique_ptr<AlterInfo> DropNotNullInfo::Deserialize(FieldReader &reader, AlterEnt
 //===--------------------------------------------------------------------===//
 // AlterForeignKeyInfo
 //===--------------------------------------------------------------------===//
+AlterForeignKeyInfo::AlterForeignKeyInfo() : AlterTableInfo(AlterTableType::FOREIGN_KEY_CONSTRAINT) {
+}
+
 AlterForeignKeyInfo::AlterForeignKeyInfo(AlterEntryData data, string fk_table, vector<string> pk_columns,
                                          vector<string> fk_columns, vector<PhysicalIndex> pk_keys,
                                          vector<PhysicalIndex> fk_keys, AlterForeignKeyType type_p)
@@ -328,6 +361,9 @@ unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, Alte
 //===--------------------------------------------------------------------===//
 // Alter View
 //===--------------------------------------------------------------------===//
+AlterViewInfo::AlterViewInfo(AlterViewType type) : AlterInfo(AlterType::ALTER_VIEW) {
+}
+
 AlterViewInfo::AlterViewInfo(AlterViewType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_VIEW, std::move(data.catalog), std::move(data.schema), std::move(data.name),
                 data.if_not_found),
@@ -368,6 +404,8 @@ unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
 //===--------------------------------------------------------------------===//
 // RenameViewInfo
 //===--------------------------------------------------------------------===//
+RenameViewInfo::RenameViewInfo() : AlterViewInfo(AlterViewType::RENAME_VIEW) {
+}
 RenameViewInfo::RenameViewInfo(AlterEntryData data, string new_name_p)
     : AlterViewInfo(AlterViewType::RENAME_VIEW, std::move(data)), new_view_name(std::move(new_name_p)) {
 }

package/src/duckdb/src/parser/parsed_data/create_index_info.cpp

@@ -11,7 +11,7 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 	result->index_type = index_type;
 	result->index_name = index_name;
 	result->constraint_type = constraint_type;
-	result->table = unique_ptr_cast<TableRef, BaseTableRef>(table->Copy());
+	result->table = table;
 	for (auto &expr : expressions) {
 		result->expressions.push_back(expr->Copy());
 	}
@@ -28,6 +28,7 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 void CreateIndexInfo::SerializeInternal(Serializer &serializer) const {
 	FieldWriter writer(serializer);
 	writer.WriteField(index_type);
+	writer.WriteString(table);
 	writer.WriteString(index_name);
 	writer.WriteField(constraint_type);
 
@@ -45,6 +46,7 @@ unique_ptr<CreateIndexInfo> CreateIndexInfo::Deserialize(Deserializer &deseriali
 
 	FieldReader reader(deserializer);
 	result->index_type = reader.ReadRequired<IndexType>();
+	result->table = reader.ReadRequired<string>();
 	result->index_name = reader.ReadRequired<string>();
 	result->constraint_type = reader.ReadRequired<IndexConstraintType>();
 

package/src/duckdb/src/parser/parsed_data/create_sequence_info.cpp

@@ -27,6 +27,7 @@ unique_ptr<CreateInfo> CreateSequenceInfo::Copy() const {
 void CreateSequenceInfo::SerializeInternal(Serializer &serializer) const {
 	FieldWriter writer(serializer);
 	writer.WriteString(name);
+	writer.WriteString(schema);
 	writer.WriteField(usage_count);
 	writer.WriteField(increment);
 	writer.WriteField(min_value);
@@ -42,6 +43,7 @@ unique_ptr<CreateSequenceInfo> CreateSequenceInfo::Deserialize(Deserializer &des
 
 	FieldReader reader(deserializer);
 	result->name = reader.ReadRequired<string>();
+	result->schema = reader.ReadRequired<string>();
 	result->usage_count = reader.ReadRequired<uint64_t>();
 	result->increment = reader.ReadRequired<int64_t>();
 	result->min_value = reader.ReadRequired<int64_t>();

package/src/duckdb/src/parser/parsed_data/detach_info.cpp

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-DetachInfo::DetachInfo() {
+DetachInfo::DetachInfo() : ParseInfo(TYPE) {
 }
 
 unique_ptr<DetachInfo> DetachInfo::Copy() const {

package/src/duckdb/src/parser/parsed_data/drop_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-DropInfo::DropInfo() : catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), cascade(false) {
+DropInfo::DropInfo() : ParseInfo(TYPE), catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), cascade(false) {
 }
 
 unique_ptr<DropInfo> DropInfo::Copy() const {

package/src/duckdb/src/parser/parsed_data/sample_options.cpp

@@ -19,24 +19,6 @@ void SampleOptions::Serialize(Serializer &serializer) {
 	writer.Finalize();
 }
 
-void SampleOptions::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("sample_size", sample_size);
-	serializer.WriteProperty("is_percentage", is_percentage);
-	serializer.WriteProperty("method", method);
-	serializer.WriteProperty("seed", seed);
-}
-
-unique_ptr<SampleOptions> SampleOptions::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = make_uniq<SampleOptions>();
-
-	deserializer.ReadProperty("sample_size", result->sample_size);
-	deserializer.ReadProperty("is_percentage", result->is_percentage);
-	deserializer.ReadProperty("method", result->method);
-	deserializer.ReadProperty("seed", result->seed);
-
-	return result;
-}
-
 unique_ptr<SampleOptions> SampleOptions::Deserialize(Deserializer &source) {
 	auto result = make_uniq<SampleOptions>();
 

package/src/duckdb/src/parser/parsed_data/transaction_info.cpp

@@ -3,7 +3,10 @@
 
 namespace duckdb {
 
-TransactionInfo::TransactionInfo(TransactionType type) : type(type) {
+TransactionInfo::TransactionInfo() : ParseInfo(TYPE) {
+}
+
+TransactionInfo::TransactionInfo(TransactionType type) : ParseInfo(TYPE), type(type) {
 }
 
 void TransactionInfo::Serialize(Serializer &serializer) const {

package/src/duckdb/src/parser/parsed_data/vacuum_info.cpp

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-VacuumInfo::VacuumInfo(VacuumOptions options) : options(options), has_table(false) {
+VacuumInfo::VacuumInfo(VacuumOptions options) : ParseInfo(TYPE), options(options), has_table(false) {
 }
 
 unique_ptr<VacuumInfo> VacuumInfo::Copy() {

package/src/duckdb/src/parser/query_node.cpp

@@ -75,16 +75,6 @@ string CommonTableExpressionMap::ToString() const {
 	return result;
 }
 
-void CommonTableExpressionMap::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("map", map);
-}
-
-CommonTableExpressionMap CommonTableExpressionMap::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = CommonTableExpressionMap();
-	deserializer.ReadProperty("map", result.map);
-	return result;
-}
-
 string QueryNode::ResultModifiersToString() const {
 	string result;
 	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {

package/src/duckdb/src/parser/result_modifier.cpp

@@ -179,19 +179,6 @@ void OrderByNode::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
-void OrderByNode::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
-	serializer.WriteProperty("null_order", null_order);
-	serializer.WriteProperty("expression", expression);
-}
-
-OrderByNode OrderByNode::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<OrderType>("type");
-	auto null_order = deserializer.ReadProperty<OrderByNullType>("null_order");
-	auto expression = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("expression");
-	return OrderByNode(type, null_order, std::move(expression));
-}
-
 OrderByNode OrderByNode::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 	auto type = reader.ReadRequired<OrderType>();

package/src/duckdb/src/parser/statement/select_statement.cpp

@@ -17,22 +17,12 @@ void SelectStatement::Serialize(Serializer &serializer) const {
 	node->Serialize(serializer);
 }
 
-void SelectStatement::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("node", node);
-}
-
 unique_ptr<SelectStatement> SelectStatement::Deserialize(Deserializer &source) {
 	auto result = make_uniq<SelectStatement>();
 	result->node = QueryNode::Deserialize(source);
 	return result;
 }
 
-unique_ptr<SelectStatement> SelectStatement::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = make_uniq<SelectStatement>();
-	deserializer.ReadProperty("node", result->node);
-	return result;
-}
-
 bool SelectStatement::Equals(const SQLStatement &other_p) const {
 	if (type != other_p.type) {
 		return false;

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -130,13 +130,6 @@ void PivotColumn::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
-void PivotColumn::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("pivot_expressions", pivot_expressions);
-	serializer.WriteProperty("unpivot_names", unpivot_names);
-	serializer.WriteProperty("entries", entries);
-	serializer.WriteProperty("pivot_enum", pivot_enum);
-}
-
 PivotColumn PivotColumn::Deserialize(Deserializer &source) {
 	PivotColumn result;
 	FieldReader reader(source);
@@ -148,15 +141,6 @@ PivotColumn PivotColumn::Deserialize(Deserializer &source) {
 	return result;
 }
 
-PivotColumn PivotColumn::FormatDeserialize(FormatDeserializer &source) {
-	PivotColumn result;
-	source.ReadProperty("pivot_expressions", result.pivot_expressions);
-	source.ReadProperty("unpivot_names", result.unpivot_names);
-	source.ReadProperty("entries", result.entries);
-	source.ReadProperty("pivot_enum", result.pivot_enum);
-	return result;
-}
-
 //===--------------------------------------------------------------------===//
 // PivotColumnEntry
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/parser/transform/statement/transform_create_index.cpp

@@ -57,12 +57,13 @@ unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery:
 	info->expressions = TransformIndexParameters(*stmt.indexParams, stmt.relation->relname);
 
 	info->index_type = StringToIndexType(string(stmt.accessMethod));
-	auto tableref = make_uniq<BaseTableRef>();
-	tableref->table_name = stmt.relation->relname;
 	if (stmt.relation->schemaname) {
-		tableref->schema_name = stmt.relation->schemaname;
+		info->schema = stmt.relation->schemaname;
 	}
-	info->table = std::move(tableref);
+	if (stmt.relation->catalogname) {
+		info->catalog = stmt.relation->catalogname;
+	}
+	info->table = stmt.relation->relname;
 	if (stmt.idxname) {
 		info->index_name = stmt.idxname;
 	} else {

package/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp

@@ -160,7 +160,7 @@ CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_col
 	for (idx_t i = 0; i < correlated_columns.size(); i++) {
 		auto &col = correlated_columns[i];
 		delim_join->duplicate_eliminated_columns.push_back(make_uniq<BoundColumnRefExpression>(col.type, col.binding));
-		delim_join->delim_types.push_back(col.type);
+		delim_join->mark_types.push_back(col.type);
 	}
 	return delim_join;
 }

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -529,7 +529,12 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		auto &base = stmt.info->Cast<CreateIndexInfo>();
 
 		// visit the table reference
-		auto bound_table = Bind(*base.table);
+		auto table_ref = make_uniq<BaseTableRef>();
+		table_ref->catalog_name = base.catalog;
+		table_ref->schema_name = base.schema;
+		table_ref->table_name = base.table;
+
+		auto bound_table = Bind(*table_ref);
 		if (bound_table->type != TableReferenceType::BASE_TABLE) {
 			throw BinderException("Can only create an index over a base table!");
 		}

package/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp

@@ -21,15 +21,25 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 	QueryErrorContext error_context(root_statement, ref.query_location);
 	// CTEs and views are also referred to using BaseTableRefs, hence need to distinguish here
 	// check if the table name refers to a CTE
-	auto found_cte = FindCTE(ref.table_name, ref.table_name == alias);
+
+	// CTE name should never be qualified (i.e. schema_name should be empty)
+	optional_ptr<CommonTableExpressionInfo> found_cte = nullptr;
+	if (ref.schema_name.empty()) {
+		found_cte = FindCTE(ref.table_name, ref.table_name == alias);
+	}
+
 	if (found_cte) {
 		// Check if there is a CTE binding in the BindContext
 		auto &cte = *found_cte;
 		auto ctebinding = bind_context.GetCTEBinding(ref.table_name);
 		if (!ctebinding) {
 			if (CTEIsAlreadyBound(cte)) {
-				throw BinderException("Circular reference to CTE \"%s\", use WITH RECURSIVE to use recursive CTEs",
-				                      ref.table_name);
+				throw BinderException(
+				    "Circular reference to CTE \"%s\", There are two possible solutions. \n1. use WITH RECURSIVE to "
+				    "use recursive CTEs. \n2. If "
+				    "you want to use the TABLE name \"%s\" the same as the CTE name, please explicitly add "
+				    "\"SCHEMA\" before table name. You can try \"main.%s\" (main is the duckdb default schema)",
+				    ref.table_name, ref.table_name, ref.table_name);
 			}
 			// Move CTE to subquery and bind recursively
 			SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(cte.query->Copy()));

package/src/duckdb/src/planner/expression/bound_between_expression.cpp

@@ -4,6 +4,10 @@
 
 namespace duckdb {
 
+BoundBetweenExpression::BoundBetweenExpression()
+    : Expression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BOUND_BETWEEN, LogicalType::BOOLEAN) {
+}
+
 BoundBetweenExpression::BoundBetweenExpression(unique_ptr<Expression> input, unique_ptr<Expression> lower,
                                                unique_ptr<Expression> upper, bool lower_inclusive, bool upper_inclusive)
     : Expression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BOUND_BETWEEN, LogicalType::BOOLEAN),

package/src/duckdb/src/planner/expression/bound_cast_expression.cpp

@@ -8,12 +8,25 @@
 
 namespace duckdb {
 
+static BoundCastInfo BindCastFunction(ClientContext &context, const LogicalType &source, const LogicalType &target) {
+	auto &cast_functions = DBConfig::GetConfig(context).GetCastFunctions();
+	GetCastFunctionInput input(context);
+	return cast_functions.GetCastFunction(source, target, input);
+}
+
 BoundCastExpression::BoundCastExpression(unique_ptr<Expression> child_p, LogicalType target_type_p,
                                          BoundCastInfo bound_cast_p, bool try_cast_p)
     : Expression(ExpressionType::OPERATOR_CAST, ExpressionClass::BOUND_CAST, std::move(target_type_p)),
       child(std::move(child_p)), try_cast(try_cast_p), bound_cast(std::move(bound_cast_p)) {
 }
 
+BoundCastExpression::BoundCastExpression(ClientContext &context, unique_ptr<Expression> child_p,
+                                         LogicalType target_type_p)
+    : Expression(ExpressionType::OPERATOR_CAST, ExpressionClass::BOUND_CAST, std::move(target_type_p)),
+      child(std::move(child_p)), try_cast(false),
+      bound_cast(BindCastFunction(context, child->return_type, return_type)) {
+}
+
 unique_ptr<Expression> AddCastExpressionInternal(unique_ptr<Expression> expr, const LogicalType &target_type,
                                                  BoundCastInfo bound_cast, bool try_cast) {
 	if (expr->return_type == target_type) {
@@ -30,12 +43,6 @@ unique_ptr<Expression> AddCastExpressionInternal(unique_ptr<Expression> expr, co
 	return make_uniq<BoundCastExpression>(std::move(expr), target_type, std::move(bound_cast), try_cast);
 }
 
-static BoundCastInfo BindCastFunction(ClientContext &context, const LogicalType &source, const LogicalType &target) {
-	auto &cast_functions = DBConfig::GetConfig(context).GetCastFunctions();
-	GetCastFunctionInput input(context);
-	return cast_functions.GetCastFunction(source, target, input);
-}
-
 unique_ptr<Expression> AddCastToTypeInternal(unique_ptr<Expression> expr, const LogicalType &target_type,
                                              CastFunctionSet &cast_functions, GetCastFunctionInput &get_input,
                                              bool try_cast) {