duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

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

@@ -3,6 +3,7 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
 #include "duckdb/common/bind_helpers.hpp"
+#include "duckdb/common/filename_pattern.hpp"
 #include "duckdb/common/local_file_system.hpp"
 #include "duckdb/execution/operator/persistent/parallel_csv_reader.hpp"
 #include "duckdb/function/table/read_csv.hpp"
@@ -62,21 +63,22 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	result.names = {"Count"};
 
 	// lookup the format in the catalog
-	auto copy_function =
+	auto &copy_function =
 	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->format);
-	if (copy_function->function.plan) {
+	if (copy_function.function.plan) {
 		// plan rewrite COPY TO
-		return copy_function->function.plan(*this, stmt);
+		return copy_function.function.plan(*this, stmt);
 	}
 
 	// bind the select statement
 	auto select_node = Bind(*stmt.select_statement);
 
-	if (!copy_function->function.copy_to_bind) {
+	if (!copy_function.function.copy_to_bind) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 	bool use_tmp_file = true;
-	bool allow_overwrite = false;
+	bool overwrite_or_ignore = false;
+	FilenamePattern filename_pattern;
 	bool user_set_use_tmp_file = false;
 	bool per_thread_output = false;
 	vector<idx_t> partition_cols;
@@ -92,11 +94,19 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 			user_set_use_tmp_file = true;
 			continue;
 		}
-		if (loption == "allow_overwrite") {
-			allow_overwrite =
+		if (loption == "overwrite_or_ignore") {
+			overwrite_or_ignore =
 			    option.second.empty() || option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
 			continue;
 		}
+		if (loption == "filename_pattern") {
+			if (option.second.empty()) {
+				throw IOException("FILENAME_PATTERN cannot be empty");
+			}
+			filename_pattern.SetFilenamePattern(
+			    option.second[0].CastAs(context, LogicalType::VARCHAR).GetValue<string>());
+			continue;
+		}
 
 		if (loption == "per_thread_output") {
 			per_thread_output =
@@ -128,13 +138,13 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	auto unique_column_names = GetUniqueNames(select_node.names);
 
 	auto function_data =
-	    copy_function->function.copy_to_bind(context, *stmt.info, unique_column_names, select_node.types);
+	    copy_function.function.copy_to_bind(context, *stmt.info, unique_column_names, select_node.types);
 	// now create the copy information
-	auto copy = make_unique<LogicalCopyToFile>(copy_function->function, std::move(function_data));
+	auto copy = make_uniq<LogicalCopyToFile>(copy_function.function, std::move(function_data));
 	copy->file_path = stmt.info->file_path;
 	copy->use_tmp_file = use_tmp_file;
-	copy->allow_overwrite = allow_overwrite;
-	copy->per_thread_output = per_thread_output;
+	copy->overwrite_or_ignore = overwrite_or_ignore;
+	copy->filename_pattern = filename_pattern;
 	copy->per_thread_output = per_thread_output;
 	copy->partition_output = !partition_cols.empty();
 	copy->partition_columns = std::move(partition_cols);
@@ -158,7 +168,9 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	result.types = {LogicalType::BIGINT};
 	result.names = {"Count"};
 
-	D_ASSERT(!stmt.info->table.empty());
+	if (stmt.info->table.empty()) {
+		throw ParserException("COPY FROM requires a table name to be specified");
+	}
 	// COPY FROM a file
 	// generate an insert statement for the the to-be-inserted table
 	InsertStatement insert;
@@ -171,21 +183,22 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	auto insert_statement = Bind(insert);
 	D_ASSERT(insert_statement.plan->type == LogicalOperatorType::LOGICAL_INSERT);
 
-	auto &bound_insert = (LogicalInsert &)*insert_statement.plan;
+	auto &bound_insert = insert_statement.plan->Cast<LogicalInsert>();
 
 	// lookup the format in the catalog
 	auto &catalog = Catalog::GetSystemCatalog(context);
-	auto copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
-	if (!copy_function->function.copy_from_bind) {
+	auto &copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
+	if (!copy_function.function.copy_from_bind) {
 		throw NotImplementedException("COPY FROM is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 	// lookup the table to copy into
 	BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
-	auto table = Catalog::GetEntry<TableCatalogEntry>(context, stmt.info->catalog, stmt.info->schema, stmt.info->table);
+	auto &table =
+	    Catalog::GetEntry<TableCatalogEntry>(context, stmt.info->catalog, stmt.info->schema, stmt.info->table);
 	vector<string> expected_names;
 	if (!bound_insert.column_index_map.empty()) {
 		expected_names.resize(bound_insert.expected_types.size());
-		for (auto &col : table->GetColumns().Logical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			auto i = col.Physical();
 			if (bound_insert.column_index_map[i] != DConstants::INVALID_INDEX) {
 				expected_names[bound_insert.column_index_map[i]] = col.Name();
@@ -193,15 +206,15 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 		}
 	} else {
 		expected_names.reserve(bound_insert.expected_types.size());
-		for (auto &col : table->GetColumns().Logical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			expected_names.push_back(col.Name());
 		}
 	}
 
 	auto function_data =
-	    copy_function->function.copy_from_bind(context, *stmt.info, expected_names, bound_insert.expected_types);
-	auto get = make_unique<LogicalGet>(GenerateTableIndex(), copy_function->function.copy_from_function,
-	                                   std::move(function_data), bound_insert.expected_types, expected_names);
+	    copy_function.function.copy_from_bind(context, *stmt.info, expected_names, bound_insert.expected_types);
+	auto get = make_uniq<LogicalGet>(GenerateTableIndex(), copy_function.function.copy_from_function,
+	                                 std::move(function_data), bound_insert.expected_types, expected_names);
 	for (idx_t i = 0; i < bound_insert.expected_types.size(); i++) {
 		get->column_ids.push_back(i);
 	}
@@ -214,19 +227,19 @@ BoundStatement Binder::Bind(CopyStatement &stmt) {
 	if (!stmt.info->is_from && !stmt.select_statement) {
 		// copy table into file without a query
 		// generate SELECT * FROM table;
-		auto ref = make_unique<BaseTableRef>();
+		auto ref = make_uniq<BaseTableRef>();
 		ref->catalog_name = stmt.info->catalog;
 		ref->schema_name = stmt.info->schema;
 		ref->table_name = stmt.info->table;
 
-		auto statement = make_unique<SelectNode>();
+		auto statement = make_uniq<SelectNode>();
 		statement->from_table = std::move(ref);
 		if (!stmt.info->select_list.empty()) {
 			for (auto &name : stmt.info->select_list) {
-				statement->select_list.push_back(make_unique<ColumnRefExpression>(name));
+				statement->select_list.push_back(make_uniq<ColumnRefExpression>(name));
 			}
 		} else {
-			statement->select_list.push_back(make_unique<StarExpression>());
+			statement->select_list.push_back(make_uniq<StarExpression>());
 		}
 		stmt.select_statement = std::move(statement);
 	}

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

@@ -8,6 +8,8 @@
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
@@ -24,6 +26,7 @@
 #include "duckdb/planner/operator/logical_create_table.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
@@ -49,9 +52,9 @@ void Binder::BindSchemaOrCatalog(ClientContext &context, string &catalog, string
 		if (database) {
 			// we have a database with this name
 			// check if there is a schema
-			auto schema_obj = Catalog::GetSchema(context, INVALID_CATALOG, schema, true);
+			auto schema_obj = Catalog::GetSchema(context, INVALID_CATALOG, schema, OnEntryNotFound::RETURN_NULL);
 			if (schema_obj) {
-				auto &attached = schema_obj->catalog->GetAttached();
+				auto &attached = schema_obj->catalog.GetAttached();
 				throw BinderException(
 				    "Ambiguous reference to catalog or schema \"%s\" - use a fully qualified path like \"%s.%s\"",
 				    schema, attached.GetName(), schema);
@@ -66,7 +69,7 @@ void Binder::BindSchemaOrCatalog(string &catalog, string &schema) {
 	BindSchemaOrCatalog(context, catalog, schema);
 }
 
-SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
+SchemaCatalogEntry &Binder::BindSchema(CreateInfo &info) {
 	BindSchemaOrCatalog(info.catalog, info.schema);
 	if (IsInvalidCatalog(info.catalog) && info.temporary) {
 		info.catalog = TEMP_CATALOG;
@@ -95,18 +98,18 @@ SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
 		}
 	}
 	// fetch the schema in which we want to create the object
-	auto schema_obj = Catalog::GetSchema(context, info.catalog, info.schema);
-	D_ASSERT(schema_obj->type == CatalogType::SCHEMA_ENTRY);
-	info.schema = schema_obj->name;
+	auto &schema_obj = Catalog::GetSchema(context, info.catalog, info.schema);
+	D_ASSERT(schema_obj.type == CatalogType::SCHEMA_ENTRY);
+	info.schema = schema_obj.name;
 	if (!info.temporary) {
-		properties.modified_databases.insert(schema_obj->catalog->GetName());
+		properties.modified_databases.insert(schema_obj.catalog.GetName());
 	}
 	return schema_obj;
 }
 
-SchemaCatalogEntry *Binder::BindCreateSchema(CreateInfo &info) {
-	auto schema = BindSchema(info);
-	if (schema->catalog->IsSystemCatalog()) {
+SchemaCatalogEntry &Binder::BindCreateSchema(CreateInfo &info) {
+	auto &schema = BindSchema(info);
+	if (schema.catalog.IsSystemCatalog()) {
 		throw BinderException("Cannot create entry in system catalog");
 	}
 	return schema;
@@ -135,18 +138,18 @@ void Binder::BindCreateViewInfo(CreateViewInfo &base) {
 static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpression> &expr) {
 	switch (expr->GetExpressionClass()) {
 	case ExpressionClass::FUNCTION: {
-		auto &func = (FunctionExpression &)*expr;
-		auto function = (StandardEntry *)Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, func.catalog,
-		                                                   func.schema, func.function_name, true);
+		auto &func = expr->Cast<FunctionExpression>();
+		auto function = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, func.catalog, func.schema,
+		                                  func.function_name, OnEntryNotFound::RETURN_NULL);
 		if (function) {
-			func.catalog = function->catalog->GetName();
-			func.schema = function->schema->name;
+			func.catalog = function->ParentCatalog().GetName();
+			func.schema = function->ParentSchema().name;
 		}
 		break;
 	}
 	case ExpressionClass::SUBQUERY: {
 		// replacing parameters within a subquery is slightly different
-		auto &sq = ((SubqueryExpression &)*expr).subquery;
+		auto &sq = (expr->Cast<SubqueryExpression>()).subquery;
 		ParsedExpressionIterator::EnumerateQueryNodeChildren(
 		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
 		break;
@@ -159,9 +162,9 @@ static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpres
 	    *expr, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
 }
 
-SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
-	auto &base = (CreateMacroInfo &)info;
-	auto &scalar_function = (ScalarMacroFunction &)*base.function;
+SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
+	auto &base = info.Cast<CreateMacroInfo>();
+	auto &scalar_function = base.function->Cast<ScalarMacroFunction>();
 
 	if (scalar_function.expression->HasParameter()) {
 		throw BinderException("Parameter expressions within macro's are not supported!");
@@ -172,7 +175,7 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	vector<string> dummy_names;
 	// positional parameters
 	for (idx_t i = 0; i < base.function->parameters.size(); i++) {
-		auto param = (ColumnRefExpression &)*base.function->parameters[i];
+		auto param = base.function->parameters[i]->Cast<ColumnRefExpression>();
 		if (param.IsQualified()) {
 			throw BinderException("Invalid parameter name '%s': must be unqualified", param.ToString());
 		}
@@ -181,11 +184,11 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	}
 	// default parameters
 	for (auto it = base.function->default_parameters.begin(); it != base.function->default_parameters.end(); it++) {
-		auto &val = (ConstantExpression &)*it->second;
+		auto &val = it->second->Cast<ConstantExpression>();
 		dummy_types.push_back(val.value.type());
 		dummy_names.push_back(it->first);
 	}
-	auto this_macro_binding = make_unique<DummyBinding>(dummy_types, dummy_names, base.name);
+	auto this_macro_binding = make_uniq<DummyBinding>(dummy_types, dummy_names, base.name);
 	macro_binding = this_macro_binding.get();
 	ExpressionBinder::QualifyColumnNames(*this, scalar_function.expression);
 	QualifyFunctionNames(context, scalar_function.expression);
@@ -195,10 +198,10 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 
 	// bind it to verify the function was defined correctly
 	string error;
-	auto sel_node = make_unique<BoundSelectNode>();
-	auto group_info = make_unique<BoundGroupInformation>();
+	auto sel_node = make_uniq<BoundSelectNode>();
+	auto group_info = make_uniq<BoundGroupInformation>();
 	SelectBinder binder(*this, context, *sel_node, *group_info);
-	error = binder.Bind(&expression, 0, false);
+	error = binder.Bind(expression, 0, false);
 
 	if (!error.empty()) {
 		throw BinderException(error);
@@ -207,7 +210,8 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	return BindCreateSchema(info);
 }
 
-void Binder::BindLogicalType(ClientContext &context, LogicalType &type, Catalog *catalog, const string &schema) {
+void Binder::BindLogicalType(ClientContext &context, LogicalType &type, optional_ptr<Catalog> catalog,
+                             const string &schema) {
 	if (type.id() == LogicalTypeId::LIST || type.id() == LogicalTypeId::MAP) {
 		auto child_type = ListType::GetChildType(type);
 		BindLogicalType(context, child_type, catalog, schema);
@@ -241,7 +245,7 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, Catalog
 	} else if (type.id() == LogicalTypeId::USER) {
 		auto &user_type_name = UserType::GetTypeName(type);
 		if (catalog) {
-			type = catalog->GetType(context, schema, user_type_name, true);
+			type = catalog->GetType(context, schema, user_type_name, OnEntryNotFound::RETURN_NULL);
 			if (type.id() == LogicalTypeId::INVALID) {
 				// look in the system catalog if the type was not found
 				type = Catalog::GetType(context, SYSTEM_CATALOG, schema, user_type_name);
@@ -251,20 +255,21 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, Catalog
 		}
 	} else if (type.id() == LogicalTypeId::ENUM) {
 		auto &enum_type_name = EnumType::GetTypeName(type);
-		TypeCatalogEntry *enum_type_catalog;
+		optional_ptr<TypeCatalogEntry> enum_type_catalog;
 		if (catalog) {
-			enum_type_catalog = catalog->GetEntry<TypeCatalogEntry>(context, schema, enum_type_name, true);
+			enum_type_catalog =
+			    catalog->GetEntry<TypeCatalogEntry>(context, schema, enum_type_name, OnEntryNotFound::RETURN_NULL);
 			if (!enum_type_catalog) {
 				// look in the system catalog if the type was not found
-				enum_type_catalog =
-				    Catalog::GetEntry<TypeCatalogEntry>(context, SYSTEM_CATALOG, schema, enum_type_name, true);
+				enum_type_catalog = Catalog::GetEntry<TypeCatalogEntry>(context, SYSTEM_CATALOG, schema, enum_type_name,
+				                                                        OnEntryNotFound::RETURN_NULL);
 			}
 		} else {
-			enum_type_catalog =
-			    Catalog::GetEntry<TypeCatalogEntry>(context, INVALID_CATALOG, schema, enum_type_name, true);
+			enum_type_catalog = Catalog::GetEntry<TypeCatalogEntry>(context, INVALID_CATALOG, schema, enum_type_name,
+			                                                        OnEntryNotFound::RETURN_NULL);
 		}
 
-		LogicalType::SetCatalog(type, enum_type_catalog);
+		EnumType::SetCatalog(type, enum_type_catalog.get());
 	}
 }
 
@@ -278,7 +283,7 @@ static void FindMatchingPrimaryKeyColumns(const ColumnList &columns, const vecto
 		if (constr->type != ConstraintType::UNIQUE) {
 			continue;
 		}
-		auto &unique = (UniqueConstraint &)*constr;
+		auto &unique = constr->Cast<UniqueConstraint>();
 		if (find_primary_key && !unique.is_primary_key) {
 			continue;
 		}
@@ -290,17 +295,30 @@ static void FindMatchingPrimaryKeyColumns(const ColumnList &columns, const vecto
 		} else {
 			pk_names = unique.columns;
 		}
-		if (pk_names.size() != fk.fk_columns.size()) {
-			// the number of referencing and referenced columns for foreign keys must be the same
-			continue;
-		}
 		if (find_primary_key) {
 			// found matching primary key
+			if (pk_names.size() != fk.fk_columns.size()) {
+				auto pk_name_str = StringUtil::Join(pk_names, ",");
+				auto fk_name_str = StringUtil::Join(fk.fk_columns, ",");
+				throw BinderException(
+				    "Failed to create foreign key: number of referencing (%s) and referenced columns (%s) differ",
+				    fk_name_str, pk_name_str);
+			}
 			fk.pk_columns = pk_names;
 			return;
 		}
-		if (fk.pk_columns != pk_names) {
-			// Name mismatch
+		if (pk_names.size() != fk.fk_columns.size()) {
+			// the number of referencing and referenced columns for foreign keys must be the same
+			continue;
+		}
+		bool equals = true;
+		for (idx_t i = 0; i < fk.pk_columns.size(); i++) {
+			if (!StringUtil::CIEquals(fk.pk_columns[i], pk_names[i])) {
+				equals = false;
+				break;
+			}
+		}
+		if (!equals) {
 			continue;
 		}
 		// found match
@@ -364,7 +382,7 @@ void ExpressionContainsGeneratedColumn(const ParsedExpression &expr, const unord
 		return;
 	}
 	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &column_ref = (ColumnRefExpression &)expr;
+		auto &column_ref = expr.Cast<ColumnRefExpression>();
 		auto &name = column_ref.GetColumnName();
 		if (gcols.count(name)) {
 			contains_gcol = true;
@@ -390,7 +408,7 @@ static bool AnyConstraintReferencesGeneratedColumn(CreateTableInfo &table_info)
 	for (auto &constr : table_info.constraints) {
 		switch (constr->type) {
 		case ConstraintType::CHECK: {
-			auto &constraint = (CheckConstraint &)*constr;
+			auto &constraint = constr->Cast<CheckConstraint>();
 			auto &expr = constraint.expression;
 			bool contains_generated_column = false;
 			ExpressionContainsGeneratedColumn(*expr, generated_columns, contains_generated_column);
@@ -400,14 +418,14 @@ static bool AnyConstraintReferencesGeneratedColumn(CreateTableInfo &table_info)
 			break;
 		}
 		case ConstraintType::NOT_NULL: {
-			auto &constraint = (NotNullConstraint &)*constr;
+			auto &constraint = constr->Cast<NotNullConstraint>();
 			if (table_info.columns.GetColumn(constraint.index).Generated()) {
 				return true;
 			}
 			break;
 		}
 		case ConstraintType::UNIQUE: {
-			auto &constraint = (UniqueConstraint &)*constr;
+			auto &constraint = constr->Cast<UniqueConstraint>();
 			auto index = constraint.index;
 			if (index.index == DConstants::INVALID_INDEX) {
 				for (auto &col : constraint.columns) {
@@ -439,10 +457,11 @@ unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateS
 	D_ASSERT(plan->type == LogicalOperatorType::LOGICAL_GET);
 	auto &base = (CreateIndexInfo &)*stmt.info;
 
-	auto &get = (LogicalGet &)*plan;
+	auto &get = plan->Cast<LogicalGet>();
 	// bind the index expressions
-	vector<unique_ptr<Expression>> expressions;
 	IndexBinder index_binder(binder, binder.context);
+	vector<unique_ptr<Expression>> expressions;
+	expressions.reserve(base.expressions.size());
 	for (auto &expr : base.expressions) {
 		expressions.push_back(index_binder.Bind(expr));
 	}
@@ -459,8 +478,8 @@ unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateS
 	create_index_info->column_ids = get.column_ids;
 
 	// the logical CREATE INDEX also needs all fields to scan the referenced table
-	return make_unique<LogicalCreateIndex>(std::move(get.bind_data), std::move(create_index_info),
-	                                       std::move(expressions), table, std::move(get.function));
+	return make_uniq<LogicalCreateIndex>(std::move(get.bind_data), std::move(create_index_info), std::move(expressions),
+	                                     table, std::move(get.function));
 }
 
 BoundStatement Binder::Bind(CreateStatement &stmt) {
@@ -471,46 +490,45 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	auto catalog_type = stmt.info->type;
 	switch (catalog_type) {
 	case CatalogType::SCHEMA_ENTRY:
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SCHEMA, std::move(stmt.info));
+		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SCHEMA, std::move(stmt.info));
 		break;
 	case CatalogType::VIEW_ENTRY: {
 		auto &base = (CreateViewInfo &)*stmt.info;
 		// bind the schema
-		auto schema = BindCreateSchema(*stmt.info);
+		auto &schema = BindCreateSchema(*stmt.info);
 		BindCreateViewInfo(base);
-		result.plan =
-		    make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_VIEW, std::move(stmt.info), schema);
+		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_VIEW, std::move(stmt.info), &schema);
 		break;
 	}
 	case CatalogType::SEQUENCE_ENTRY: {
-		auto schema = BindCreateSchema(*stmt.info);
+		auto &schema = BindCreateSchema(*stmt.info);
 		result.plan =
-		    make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SEQUENCE, std::move(stmt.info), schema);
+		    make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SEQUENCE, std::move(stmt.info), &schema);
 		break;
 	}
 	case CatalogType::TABLE_MACRO_ENTRY: {
-		auto schema = BindCreateSchema(*stmt.info);
+		auto &schema = BindCreateSchema(*stmt.info);
 		result.plan =
-		    make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), schema);
+		    make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), &schema);
 		break;
 	}
 	case CatalogType::MACRO_ENTRY: {
-		auto schema = BindCreateFunctionInfo(*stmt.info);
+		auto &schema = BindCreateFunctionInfo(*stmt.info);
 		result.plan =
-		    make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), schema);
+		    make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), &schema);
 		break;
 	}
 	case CatalogType::INDEX_ENTRY: {
-		auto &base = (CreateIndexInfo &)*stmt.info;
+		auto &base = stmt.info->Cast<CreateIndexInfo>();
 
 		// visit the table reference
 		auto bound_table = Bind(*base.table);
 		if (bound_table->type != TableReferenceType::BASE_TABLE) {
 			throw BinderException("Can only create an index over a base table!");
 		}
-		auto &table_binding = (BoundBaseTableRef &)*bound_table;
-		auto table = table_binding.table;
-		if (table->temporary) {
+		auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
+		auto &table = table_binding.table;
+		if (table.temporary) {
 			stmt.info->temporary = true;
 		}
 		// create a plan over the bound table
@@ -519,26 +537,26 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			throw BinderException("Cannot create index on a view!");
 		}
 
-		result.plan = table->catalog->BindCreateIndex(*this, stmt, *table, std::move(plan));
+		result.plan = table.catalog.BindCreateIndex(*this, stmt, table, std::move(plan));
 		break;
 	}
 	case CatalogType::TABLE_ENTRY: {
-		auto &create_info = (CreateTableInfo &)*stmt.info;
+		auto &create_info = stmt.info->Cast<CreateTableInfo>();
 		// If there is a foreign key constraint, resolve primary key column's index from primary key column's name
-		unordered_set<SchemaCatalogEntry *> fk_schemas;
+		reference_set_t<SchemaCatalogEntry> fk_schemas;
 		for (idx_t i = 0; i < create_info.constraints.size(); i++) {
 			auto &cond = create_info.constraints[i];
 			if (cond->type != ConstraintType::FOREIGN_KEY) {
 				continue;
 			}
-			auto &fk = (ForeignKeyConstraint &)*cond;
+			auto &fk = cond->Cast<ForeignKeyConstraint>();
 			if (fk.info.type != ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
 				continue;
 			}
 			D_ASSERT(fk.info.pk_keys.empty());
 			D_ASSERT(fk.info.fk_keys.empty());
 			FindForeignKeyIndexes(create_info.columns, fk.fk_columns, fk.info.fk_keys);
-			if (create_info.table == fk.info.table) {
+			if (StringUtil::CIEquals(create_info.table, fk.info.table)) {
 				// self-referential foreign key constraint
 				fk.info.type = ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE;
 				FindMatchingPrimaryKeyColumns(create_info.columns, create_info.constraints, fk);
@@ -546,21 +564,20 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 				CheckForeignKeyTypes(create_info.columns, create_info.columns, fk);
 			} else {
 				// have to resolve referenced table
-				auto pk_table_entry_ptr =
+				auto &pk_table_entry_ptr =
 				    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, fk.info.schema, fk.info.table);
-				fk_schemas.insert(pk_table_entry_ptr->schema);
-				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr->GetColumns(), pk_table_entry_ptr->GetConstraints(),
-				                              fk);
-				FindForeignKeyIndexes(pk_table_entry_ptr->GetColumns(), fk.pk_columns, fk.info.pk_keys);
-				CheckForeignKeyTypes(pk_table_entry_ptr->GetColumns(), create_info.columns, fk);
-				auto &storage = pk_table_entry_ptr->GetStorage();
+				fk_schemas.insert(pk_table_entry_ptr.schema);
+				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr.GetColumns(), pk_table_entry_ptr.GetConstraints(), fk);
+				FindForeignKeyIndexes(pk_table_entry_ptr.GetColumns(), fk.pk_columns, fk.info.pk_keys);
+				CheckForeignKeyTypes(pk_table_entry_ptr.GetColumns(), create_info.columns, fk);
+				auto &storage = pk_table_entry_ptr.GetStorage();
 				auto index = storage.info->indexes.FindForeignKeyIndex(fk.info.pk_keys,
 				                                                       ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE);
 				if (!index) {
 					auto fk_column_names = StringUtil::Join(fk.pk_columns, ",");
 					throw BinderException("Failed to create foreign key on %s(%s): no UNIQUE or PRIMARY KEY constraint "
 					                      "present on these columns",
-					                      pk_table_entry_ptr->name, fk_column_names);
+					                      pk_table_entry_ptr.name, fk_column_names);
 				}
 			}
 			D_ASSERT(fk.info.pk_keys.size() == fk.info.fk_keys.size());
@@ -573,14 +590,14 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		auto bound_info = BindCreateTableInfo(std::move(stmt.info));
 		auto root = std::move(bound_info->query);
 		for (auto &fk_schema : fk_schemas) {
-			if (fk_schema != bound_info->schema) {
+			if (&fk_schema.get() != &bound_info->schema) {
 				throw BinderException("Creating foreign keys across different schemas or catalogs is not supported");
 			}
 		}
 
 		// create the logical operator
 		auto &schema = bound_info->schema;
-		auto create_table = make_unique<LogicalCreateTable>(schema, std::move(bound_info));
+		auto create_table = make_uniq<LogicalCreateTable>(schema, std::move(bound_info));
 		if (root) {
 			// CREATE TABLE AS
 			properties.return_type = StatementReturnType::CHANGED_ROWS;
@@ -590,43 +607,28 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		break;
 	}
 	case CatalogType::TYPE_ENTRY: {
-		auto schema = BindCreateSchema(*stmt.info);
-		auto &create_type_info = (CreateTypeInfo &)(*stmt.info);
-		result.plan =
-		    make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, std::move(stmt.info), schema);
+		auto &schema = BindCreateSchema(*stmt.info);
+		auto &create_type_info = stmt.info->Cast<CreateTypeInfo>();
+		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, std::move(stmt.info), &schema);
 		if (create_type_info.query) {
 			// CREATE TYPE mood AS ENUM (SELECT 'happy')
-			auto &select_stmt = (SelectStatement &)*create_type_info.query;
-			auto &query_node = *select_stmt.node;
-
-			// We always add distinct modifier implicitly
-			bool need_to_add = true;
-			if (!query_node.modifiers.empty()) {
-				if (query_node.modifiers[0]->type == ResultModifierType::DISTINCT_MODIFIER) {
-					// There are cases where the same column is grouped repeatedly
-					// CREATE TYPE mood AS ENUM (SELECT DISTINCT ON(x) x FROM test);
-					// When we push into a constant expression
-					// => CREATE TYPE mood AS ENUM (SELECT DISTINCT ON(x, x) x FROM test);
-					auto &distinct_modifier = (DistinctModifier &)*query_node.modifiers[0];
-					distinct_modifier.distinct_on_targets.push_back(make_unique<ConstantExpression>(Value::INTEGER(1)));
-					need_to_add = false;
-				}
-			}
-
-			// Add distinct modifier
-			if (need_to_add) {
-				auto distinct_modifier = make_unique<DistinctModifier>();
-				distinct_modifier->distinct_on_targets.push_back(make_unique<ConstantExpression>(Value::INTEGER(1)));
-				query_node.modifiers.emplace(query_node.modifiers.begin(), std::move(distinct_modifier));
-			}
-
 			auto query_obj = Bind(*create_type_info.query);
 			auto query = std::move(query_obj.plan);
 
 			auto &sql_types = query_obj.types;
-			if (sql_types.size() != 1 || sql_types[0].id() != LogicalType::VARCHAR) {
+			if (sql_types.size() != 1) {
 				// add cast expression?
-				throw BinderException("The query must return one varchar column");
+				throw BinderException("The query must return a single column");
+			}
+			if (sql_types[0].id() != LogicalType::VARCHAR) {
+				// push a projection casting to varchar
+				vector<unique_ptr<Expression>> select_list;
+				auto ref = make_uniq<BoundColumnRefExpression>(sql_types[0], query->GetColumnBindings()[0]);
+				auto cast_expr = BoundCastExpression::AddCastToType(context, std::move(ref), LogicalType::VARCHAR);
+				select_list.push_back(std::move(cast_expr));
+				auto proj = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
+				proj->AddChild(std::move(query));
+				query = std::move(proj);
 			}
 
 			result.plan->AddChild(std::move(query));
@@ -636,10 +638,10 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			// 2: create a type alias with a custom type.
 			// eg. CREATE TYPE a AS INT; CREATE TYPE b AS a;
 			// We set b to be an alias for the underlying type of a
-			auto inner_type = Catalog::GetType(context, schema->catalog->GetName(), schema->name,
+			auto inner_type = Catalog::GetType(context, schema.catalog.GetName(), schema.name,
 			                                   UserType::GetTypeName(create_type_info.type));
 			// clear to nullptr, we don't need this
-			LogicalType::SetCatalog(inner_type, nullptr);
+			EnumType::SetCatalog(inner_type, nullptr);
 			inner_type.SetAlias(create_type_info.name);
 			create_type_info.type = inner_type;
 		}
@@ -647,7 +649,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	}
 	case CatalogType::DATABASE_ENTRY: {
 		// not supported in DuckDB yet but allow extensions to intercept and implement this functionality
-		auto &base = (CreateDatabaseInfo &)*stmt.info;
+		auto &base = stmt.info->Cast<CreateDatabaseInfo>();
 		string database_name = base.name;
 		string source_path = base.path;