duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

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

@@ -24,7 +24,6 @@
 #include "duckdb/planner/operator/logical_create_index.hpp"
 #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"
@@ -39,6 +38,7 @@
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/catalog/duck_catalog.hpp"
+#include "duckdb/function/table/table_scan.hpp"
 
 namespace duckdb {
 
@@ -134,33 +134,6 @@ void Binder::BindCreateViewInfo(CreateViewInfo &base) {
 	base.types = query_node.types;
 }
 
-static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpression> &expr) {
-	switch (expr->GetExpressionClass()) {
-	case ExpressionClass::FUNCTION: {
-		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->ParentCatalog().GetName();
-			func.schema = function->ParentSchema().name;
-		}
-		break;
-	}
-	case ExpressionClass::SUBQUERY: {
-		// replacing parameters within a subquery is slightly different
-		auto &sq = (expr->Cast<SubqueryExpression>()).subquery;
-		ParsedExpressionIterator::EnumerateQueryNodeChildren(
-		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
-		break;
-	}
-	default: // fall through
-		break;
-	}
-	// unfold child expressions
-	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
-}
-
 SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto &base = info.Cast<CreateMacroInfo>();
 	auto &scalar_function = base.function->Cast<ScalarMacroFunction>();
@@ -190,7 +163,6 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	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);
 
 	// create a copy of the expression because we do not want to alter the original
 	auto expression = scalar_function.expression->Copy();
@@ -260,23 +232,7 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, optional
 		} else {
 			type = Catalog::GetType(context, INVALID_CATALOG, schema, user_type_name);
 		}
-	} else if (type.id() == LogicalTypeId::ENUM) {
-		auto enum_type_name = EnumType::GetTypeName(type);
-		optional_ptr<TypeCatalogEntry> enum_type_catalog;
-		if (catalog) {
-			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,
-				                                                        OnEntryNotFound::RETURN_NULL);
-			}
-		} else {
-			enum_type_catalog = Catalog::GetEntry<TypeCatalogEntry>(context, INVALID_CATALOG, schema, enum_type_name,
-			                                                        OnEntryNotFound::RETURN_NULL);
-		}
-
-		EnumType::SetCatalog(type, enum_type_catalog.get());
+		BindLogicalType(context, type, catalog, schema);
 	}
 }
 
@@ -483,10 +439,14 @@ unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateS
 	create_index_info->scan_types.emplace_back(LogicalType::ROW_TYPE);
 	create_index_info->names = get.names;
 	create_index_info->column_ids = get.column_ids;
+	auto &bind_data = get.bind_data->Cast<TableScanBindData>();
+	bind_data.is_create_index = true;
+	get.column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 
 	// the logical CREATE INDEX also needs all fields to scan the referenced table
-	return make_uniq<LogicalCreateIndex>(std::move(get.bind_data), std::move(create_index_info), std::move(expressions),
-	                                     table, std::move(get.function));
+	auto result = make_uniq<LogicalCreateIndex>(std::move(create_index_info), std::move(expressions), table);
+	result->children.push_back(std::move(plan));
+	return std::move(result);
 }
 
 BoundStatement Binder::Bind(CreateStatement &stmt) {
@@ -529,7 +489,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!");
 		}
@@ -543,7 +508,6 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		if (plan->type != LogicalOperatorType::LOGICAL_GET) {
 			throw BinderException("Cannot create index on a view!");
 		}
-
 		result.plan = table.catalog.BindCreateIndex(*this, stmt, table, std::move(plan));
 		break;
 	}
@@ -648,8 +612,6 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			// We set b to be an alias for the underlying type of a
 			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
-			EnumType::SetCatalog(inner_type, nullptr);
 			inner_type.SetAlias(create_type_info.name);
 			create_type_info.type = inner_type;
 		}

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

@@ -292,29 +292,6 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 			ExpressionBinder::TestCollation(context, StringType::GetCollation(column.Type()));
 		}
 		BindLogicalType(context, column.TypeMutable(), &result->schema.catalog);
-		// We add a catalog dependency
-		auto type_dependency = EnumType::GetCatalog(column.Type());
-
-		if (type_dependency) {
-			// Only if the USER comes from a create type
-			if (!schema.catalog.IsTemporaryCatalog()) {
-				// If it is not a TEMP table we add a dependency
-				result->dependencies.AddDependency(*type_dependency);
-			} else {
-				auto enum_type = type_dependency->user_type;
-				auto &enum_entries = EnumType::GetValuesInsertOrder(enum_type);
-				auto enum_size = EnumType::GetSize(enum_type);
-				Vector copy_enum_entries_vec(LogicalType::VARCHAR, enum_size);
-				auto copy_enum_entries_ptr = FlatVector::GetData<string_t>(copy_enum_entries_vec);
-				auto enum_entries_ptr = FlatVector::GetData<string_t>(enum_entries);
-				for (idx_t enum_idx = 0; enum_idx < enum_size; enum_idx++) {
-					copy_enum_entries_ptr[enum_idx] =
-					    StringVector::AddStringOrBlob(copy_enum_entries_vec, enum_entries_ptr[enum_idx]);
-				}
-				auto copy_type = LogicalType::ENUM(EnumType::GetTypeName(enum_type), copy_enum_entries_vec, enum_size);
-				column.SetType(copy_type);
-			}
-		}
 	}
 	result->dependencies.VerifyDependencies(schema.catalog, result->Base().table);
 	properties.allow_stream_result = false;

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

@@ -39,6 +39,9 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 		if (!entry) {
 			break;
 		}
+		if (entry->internal) {
+			throw CatalogException("Cannot drop internal catalog entry \"%s\"!", entry->name);
+		}
 		stmt.info->catalog = entry->ParentCatalog().GetName();
 		if (!entry->temporary) {
 			// we can only drop temporary tables in read-only mode

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

@@ -6,6 +6,7 @@
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 
@@ -23,24 +24,29 @@ BoundStatement Binder::Bind(ExecuteStatement &stmt) {
 	// check if we need to rebind the prepared statement
 	// this happens if the catalog changes, since in this case e.g. tables we relied on may have been deleted
 	auto prepared = entry->second;
+	auto &named_param_map = prepared->unbound_statement->named_param_map;
 
+	PreparedStatement::VerifyParameters(stmt.named_values, named_param_map);
+
+	auto &mapped_named_values = stmt.named_values;
 	// bind any supplied parameters
-	vector<Value> bind_values;
+	case_insensitive_map_t<Value> bind_values;
 	auto constant_binder = Binder::CreateBinder(context);
 	constant_binder->SetCanContainNulls(true);
-	for (idx_t i = 0; i < stmt.values.size(); i++) {
+	for (auto &pair : mapped_named_values) {
 		ConstantBinder cbinder(*constant_binder, context, "EXECUTE statement");
-		auto bound_expr = cbinder.Bind(stmt.values[i]);
+		auto bound_expr = cbinder.Bind(pair.second);
 
 		Value value = ExpressionExecutor::EvaluateScalar(context, *bound_expr, true);
-		bind_values.push_back(std::move(value));
+		bind_values[pair.first] = std::move(value);
 	}
 	unique_ptr<LogicalOperator> rebound_plan;
-	if (prepared->RequireRebind(context, bind_values)) {
+
+	if (prepared->RequireRebind(context, &bind_values)) {
 		// catalog was modified or statement does not have clear types: rebind the statement before running the execute
 		Planner prepared_planner(context);
-		for (idx_t i = 0; i < bind_values.size(); i++) {
-			prepared_planner.parameter_data.emplace_back(bind_values[i]);
+		for (auto &pair : bind_values) {
+			prepared_planner.parameter_data.emplace(std::make_pair(pair.first, BoundParameterData(pair.second)));
 		}
 		prepared = prepared_planner.PrepareSQLStatement(entry->second->unbound_statement->Copy());
 		rebound_plan = std::move(prepared_planner.plan);

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

@@ -11,6 +11,9 @@
 #include "duckdb/planner/operator/logical_set_operation.hpp"
 #include "duckdb/parser/parsed_data/exported_table_data.hpp"
 #include "duckdb/parser/constraints/foreign_key_constraint.hpp"
+#include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
 
 #include "duckdb/common/string_util.hpp"
 #include <algorithm>
@@ -41,47 +44,63 @@ string SanitizeExportIdentifier(const string &str) {
 	return result;
 }
 
-bool IsExistMainKeyTable(string &table_name, vector<reference<TableCatalogEntry>> &unordered) {
-	for (idx_t i = 0; i < unordered.size(); i++) {
-		if (unordered[i].get().name == table_name) {
+bool ReferencedTableIsOrdered(string &referenced_table, catalog_entry_vector_t &ordered) {
+	for (auto &entry : ordered) {
+		auto &table_entry = entry.get().Cast<TableCatalogEntry>();
+		if (StringUtil::CIEquals(table_entry.name, referenced_table)) {
+			// The referenced table is already ordered
 			return true;
 		}
 	}
 	return false;
 }
 
-void ScanForeignKeyTable(vector<reference<TableCatalogEntry>> &ordered, vector<reference<TableCatalogEntry>> &unordered,
-                         bool move_only_pk_table) {
-	for (auto i = unordered.begin(); i != unordered.end();) {
-		auto table_entry = *i;
+void ScanForeignKeyTable(catalog_entry_vector_t &ordered, catalog_entry_vector_t &unordered,
+                         bool move_primary_keys_only) {
+	catalog_entry_vector_t remaining;
+
+	for (auto &entry : unordered) {
+		auto &table_entry = entry.get().Cast<TableCatalogEntry>();
 		bool move_to_ordered = true;
-		auto &constraints = table_entry.get().GetConstraints();
-		for (idx_t j = 0; j < constraints.size(); j++) {
-			auto &cond = constraints[j];
-			if (cond->type == ConstraintType::FOREIGN_KEY) {
-				auto &fk = cond->Cast<ForeignKeyConstraint>();
-				if ((move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) ||
-				    (!move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE &&
-				     IsExistMainKeyTable(fk.info.table, unordered))) {
-					move_to_ordered = false;
-					break;
-				}
+		auto &constraints = table_entry.GetConstraints();
+
+		for (auto &cond : constraints) {
+			if (cond->type != ConstraintType::FOREIGN_KEY) {
+				continue;
+			}
+			auto &fk = cond->Cast<ForeignKeyConstraint>();
+			if (fk.info.type != ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
+				continue;
+			}
+
+			if (move_primary_keys_only) {
+				// This table references a table, don't move it yet
+				move_to_ordered = false;
+				break;
+			} else if (!ReferencedTableIsOrdered(fk.info.table, ordered)) {
+				// The table that it references isn't ordered yet
+				move_to_ordered = false;
+				break;
 			}
 		}
+
 		if (move_to_ordered) {
 			ordered.push_back(table_entry);
-			i = unordered.erase(i);
 		} else {
-			i++;
+			remaining.push_back(table_entry);
 		}
 	}
+	unordered = remaining;
 }
 
-void ReorderTableEntries(vector<reference<TableCatalogEntry>> &tables) {
-	vector<reference<TableCatalogEntry>> ordered;
-	vector<reference<TableCatalogEntry>> unordered = tables;
+void ReorderTableEntries(catalog_entry_vector_t &tables) {
+	catalog_entry_vector_t ordered;
+	catalog_entry_vector_t unordered = tables;
+	// First only move the tables that don't have any dependencies
 	ScanForeignKeyTable(ordered, unordered, true);
 	while (!unordered.empty()) {
+		// Now we will start moving tables that have foreign key constraints
+		// if the tables they reference are already moved
 		ScanForeignKeyTable(ordered, unordered, false);
 	}
 	tables = ordered;
@@ -96,6 +115,120 @@ string CreateFileName(const string &id_suffix, TableCatalogEntry &table, const s
 	return StringUtil::Format("%s_%s%s.%s", schema, name, id_suffix, extension);
 }
 
+static bool IsSupported(CopyTypeSupport support_level) {
+	// For export purposes we don't want to lose information, so we only accept fully supported types
+	return support_level == CopyTypeSupport::SUPPORTED;
+}
+
+static LogicalType AlterLogicalType(const LogicalType &original, copy_supports_type_t type_check) {
+	D_ASSERT(type_check);
+	auto id = original.id();
+	switch (id) {
+	case LogicalTypeId::LIST: {
+		auto child = AlterLogicalType(ListType::GetChildType(original), type_check);
+		return LogicalType::LIST(child);
+	}
+	case LogicalTypeId::STRUCT: {
+		auto &original_children = StructType::GetChildTypes(original);
+		child_list_t<LogicalType> new_children;
+		for (auto &child : original_children) {
+			auto &child_name = child.first;
+			auto &child_type = child.second;
+
+			LogicalType new_type;
+			if (!IsSupported(type_check(child_type))) {
+				new_type = AlterLogicalType(child_type, type_check);
+			} else {
+				new_type = child_type;
+			}
+			new_children.push_back(std::make_pair(child_name, new_type));
+		}
+		return LogicalType::STRUCT(std::move(new_children));
+	}
+	case LogicalTypeId::UNION: {
+		auto member_count = UnionType::GetMemberCount(original);
+		child_list_t<LogicalType> new_children;
+		for (idx_t i = 0; i < member_count; i++) {
+			auto &child_name = UnionType::GetMemberName(original, i);
+			auto &child_type = UnionType::GetMemberType(original, i);
+
+			LogicalType new_type;
+			if (!IsSupported(type_check(child_type))) {
+				new_type = AlterLogicalType(child_type, type_check);
+			} else {
+				new_type = child_type;
+			}
+
+			new_children.push_back(std::make_pair(child_name, new_type));
+		}
+		return LogicalType::UNION(std::move(new_children));
+	}
+	case LogicalTypeId::MAP: {
+		auto &key_type = MapType::KeyType(original);
+		auto &value_type = MapType::ValueType(original);
+
+		LogicalType new_key_type;
+		LogicalType new_value_type;
+		if (!IsSupported(type_check(key_type))) {
+			new_key_type = AlterLogicalType(key_type, type_check);
+		} else {
+			new_key_type = key_type;
+		}
+
+		if (!IsSupported(type_check(value_type))) {
+			new_value_type = AlterLogicalType(value_type, type_check);
+		} else {
+			new_value_type = value_type;
+		}
+		return LogicalType::MAP(new_key_type, new_value_type);
+	}
+	default: {
+		D_ASSERT(!IsSupported(type_check(original)));
+		return LogicalType::VARCHAR;
+	}
+	}
+}
+
+static bool NeedsCast(LogicalType &type, copy_supports_type_t type_check) {
+	if (!type_check) {
+		return false;
+	}
+	if (IsSupported(type_check(type))) {
+		// The type is supported in it's entirety, no cast is required
+		return false;
+	}
+	// Change the type to something that is supported
+	type = AlterLogicalType(type, type_check);
+	return true;
+}
+
+static unique_ptr<QueryNode> CreateSelectStatement(CopyStatement &stmt, child_list_t<LogicalType> &select_list,
+                                                   copy_supports_type_t type_check) {
+	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_uniq<SelectNode>();
+	statement->from_table = std::move(ref);
+
+	vector<unique_ptr<ParsedExpression>> expressions;
+	for (auto &col : select_list) {
+		auto &name = col.first;
+		auto &type = col.second;
+
+		auto expression = make_uniq_base<ParsedExpression, ColumnRefExpression>(name);
+		if (NeedsCast(type, type_check)) {
+			// Add a cast to a type supported by the copy function
+			expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(expression));
+		}
+		expressions.push_back(std::move(expression));
+	}
+
+	statement->select_list = std::move(expressions);
+	return std::move(statement);
+}
+
 BoundStatement Binder::Bind(ExportStatement &stmt) {
 	// COPY TO a file
 	auto &config = DBConfig::GetConfig(context);
@@ -115,7 +248,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 
 	// gather a list of all the tables
 	string catalog = stmt.database.empty() ? INVALID_CATALOG : stmt.database;
-	vector<reference<TableCatalogEntry>> tables;
+	catalog_entry_vector_t tables;
 	auto schemas = Catalog::GetSchemas(context, catalog);
 	for (auto &schema : schemas) {
 		schema.get().Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
@@ -136,7 +269,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 
 	unordered_set<string> table_name_index;
 	for (auto &t : tables) {
-		auto &table = t.get();
+		auto &table = t.get().Cast<TableCatalogEntry>();
 		auto info = make_uniq<CopyInfo>();
 		// we copy the options supplied to the EXPORT
 		info->format = stmt.info->format;
@@ -163,8 +296,10 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		info->table = table.name;
 
 		// We can not export generated columns
+		child_list_t<LogicalType> select_list;
+
 		for (auto &col : table.GetColumns().Physical()) {
-			info->select_list.push_back(col.GetName());
+			select_list.push_back(std::make_pair(col.Name(), col.Type()));
 		}
 
 		ExportedTableData exported_data;
@@ -181,17 +316,20 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		// generate the copy statement and bind it
 		CopyStatement copy_stmt;
 		copy_stmt.info = std::move(info);
+		copy_stmt.select_statement =
+		    CreateSelectStatement(copy_stmt, select_list, copy_function.function.supports_type);
 
 		auto copy_binder = Binder::CreateBinder(context, this);
 		auto bound_statement = copy_binder->Bind(copy_stmt);
+		auto plan = std::move(bound_statement.plan);
+
 		if (child_operator) {
 			// use UNION ALL to combine the individual copy statements into a single node
-			auto copy_union =
-			    make_uniq<LogicalSetOperation>(GenerateTableIndex(), 1, std::move(child_operator),
-			                                   std::move(bound_statement.plan), LogicalOperatorType::LOGICAL_UNION);
+			auto copy_union = make_uniq<LogicalSetOperation>(GenerateTableIndex(), 1, std::move(child_operator),
+			                                                 std::move(plan), LogicalOperatorType::LOGICAL_UNION);
 			child_operator = std::move(copy_union);
 		} else {
-			child_operator = std::move(bound_statement.plan);
+			child_operator = std::move(plan);
 		}
 	}
 

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

@@ -10,6 +10,7 @@
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/main/extension_helper.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/planner/tableref/bound_dummytableref.hpp"
@@ -17,19 +18,85 @@
 
 namespace duckdb {
 
+static bool TryLoadExtensionForReplacementScan(ClientContext &context, const string &table_name) {
+	auto lower_name = StringUtil::Lower(table_name);
+	auto &dbconfig = DBConfig::GetConfig(context);
+
+	if (!dbconfig.options.autoload_known_extensions) {
+		return false;
+	}
+
+	for (const auto &entry : EXTENSION_FILE_POSTFIXES) {
+		if (StringUtil::EndsWith(lower_name, entry.name)) {
+			ExtensionHelper::AutoLoadExtension(context, entry.extension);
+			return true;
+		}
+	}
+
+	for (const auto &entry : EXTENSION_FILE_CONTAINS) {
+		if (StringUtil::Contains(lower_name, entry.name)) {
+			ExtensionHelper::AutoLoadExtension(context, entry.extension);
+			return true;
+		}
+	}
+
+	return false;
+}
+
+unique_ptr<BoundTableRef> Binder::BindWithReplacementScan(ClientContext &context, const string &table_name,
+                                                          BaseTableRef &ref) {
+	auto &config = DBConfig::GetConfig(context);
+	if (context.config.use_replacement_scans) {
+		for (auto &scan : config.replacement_scans) {
+			auto replacement_function = scan.function(context, table_name, scan.data.get());
+			if (replacement_function) {
+				if (!ref.alias.empty()) {
+					// user-provided alias overrides the default alias
+					replacement_function->alias = ref.alias;
+				} else if (replacement_function->alias.empty()) {
+					// if the replacement scan itself did not provide an alias we use the table name
+					replacement_function->alias = ref.table_name;
+				}
+				if (replacement_function->type == TableReferenceType::TABLE_FUNCTION) {
+					auto &table_function = replacement_function->Cast<TableFunctionRef>();
+					table_function.column_name_alias = ref.column_name_alias;
+				} else if (replacement_function->type == TableReferenceType::SUBQUERY) {
+					auto &subquery = replacement_function->Cast<SubqueryRef>();
+					subquery.column_name_alias = ref.column_name_alias;
+				} else {
+					throw InternalException("Replacement scan should return either a table function or a subquery");
+				}
+				return Bind(*replacement_function);
+			}
+		}
+	}
+
+	return nullptr;
+}
+
 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()));
@@ -45,9 +112,18 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 			return Bind(subquery, found_cte);
 		} else {
 			// There is a CTE binding in the BindContext.
-			// This can only be the case if there is a recursive CTE present.
+			// This can only be the case if there is a recursive CTE,
+			// or a materialized CTE present.
 			auto index = GenerateTableIndex();
-			auto result = make_uniq<BoundCTERef>(index, ctebinding->index);
+			auto materialized = cte.materialized;
+			if (materialized == CTEMaterialize::CTE_MATERIALIZE_DEFAULT) {
+#ifdef DUCKDB_ALTERNATIVE_VERIFY
+				materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
+#else
+				materialized = CTEMaterialize::CTE_MATERIALIZE_NEVER;
+#endif
+			}
+			auto result = make_uniq<BoundCTERef>(index, ctebinding->index, materialized);
 			auto b = ctebinding;
 			auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
 			auto names = BindContext::AliasColumnNames(alias, b->names, ref.column_name_alias);
@@ -89,29 +165,18 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		}
 		table_name += (!table_name.empty() ? "." : "") + ref.table_name;
 		// table could not be found: try to bind a replacement scan
-		auto &config = DBConfig::GetConfig(context);
-		if (context.config.use_replacement_scans) {
-			for (auto &scan : config.replacement_scans) {
-				auto replacement_function = scan.function(context, table_name, scan.data.get());
-				if (replacement_function) {
-					if (!ref.alias.empty()) {
-						// user-provided alias overrides the default alias
-						replacement_function->alias = ref.alias;
-					} else if (replacement_function->alias.empty()) {
-						// if the replacement scan itself did not provide an alias we use the table name
-						replacement_function->alias = ref.table_name;
-					}
-					if (replacement_function->type == TableReferenceType::TABLE_FUNCTION) {
-						auto &table_function = replacement_function->Cast<TableFunctionRef>();
-						table_function.column_name_alias = ref.column_name_alias;
-					} else if (replacement_function->type == TableReferenceType::SUBQUERY) {
-						auto &subquery = replacement_function->Cast<SubqueryRef>();
-						subquery.column_name_alias = ref.column_name_alias;
-					} else {
-						throw InternalException("Replacement scan should return either a table function or a subquery");
-					}
-					return Bind(*replacement_function);
-				}
+		// Try replacement scan bind
+		auto replacement_scan_bind_result = BindWithReplacementScan(context, table_name, ref);
+		if (replacement_scan_bind_result) {
+			return replacement_scan_bind_result;
+		}
+
+		// Try autoloading an extension, then retry the replacement scan bind
+		auto extension_loaded = TryLoadExtensionForReplacementScan(context, table_name);
+		if (extension_loaded) {
+			replacement_scan_bind_result = BindWithReplacementScan(context, table_name, ref);
+			if (replacement_scan_bind_result) {
+				return replacement_scan_bind_result;
 			}
 		}