duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

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

@@ -1,20 +1,20 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/main/extension_helper.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/tableref/basetableref.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
-#include "duckdb/planner/tableref/bound_subqueryref.hpp"
 #include "duckdb/planner/tableref/bound_cteref.hpp"
-#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"
-#include "duckdb/main/client_context.hpp"
+#include "duckdb/planner/tableref/bound_subqueryref.hpp"
 
 namespace duckdb {
 
@@ -43,14 +43,13 @@ static bool TryLoadExtensionForReplacementScan(ClientContext &context, const str
 	return false;
 }
 
-unique_ptr<BoundTableRef> Binder::BindWithReplacementScan(ClientContext &context, const string &table_name,
-                                                          BaseTableRef &ref) {
+unique_ptr<BoundTableRef> Binder::BindWithReplacementScan(ClientContext &context, BaseTableRef &ref) {
 	auto &config = DBConfig::GetConfig(context);
 	if (!context.config.use_replacement_scans) {
 		return nullptr;
 	}
 	for (auto &scan : config.replacement_scans) {
-		ReplacementScanInput input(ref.Cast<TableRef>(), table_name);
+		ReplacementScanInput input(ref.catalog_name, ref.schema_name, ref.table_name);
 		auto replacement_function = scan.function(context, input, scan.data.get());
 		if (!replacement_function) {
 			continue;
@@ -71,6 +70,9 @@ unique_ptr<BoundTableRef> Binder::BindWithReplacementScan(ClientContext &context
 		} else {
 			throw InternalException("Replacement scan should return either a table function or a subquery");
 		}
+		if (GetBindingMode() == BindingMode::EXTRACT_REPLACEMENT_SCANS) {
+			AddReplacementScan(ref.table_name, replacement_function->Copy());
+		}
 		return Bind(*replacement_function);
 	}
 	return nullptr;
@@ -93,26 +95,8 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		for (auto found_cte : found_ctes) {
 			auto &cte = found_cte.get();
 			auto ctebinding = bind_context.GetCTEBinding(ref.table_name);
-			if (!ctebinding) {
-				if (CTEIsAlreadyBound(cte)) {
-					// remember error state
-					circular_cte = true;
-					// retry with next candidate CTE
-					continue;
-				}
-				// Move CTE to subquery and bind recursively
-				SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(cte.query->Copy()));
-				subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias;
-				subquery.column_name_alias = cte.aliases;
-				for (idx_t i = 0; i < ref.column_name_alias.size(); i++) {
-					if (i < subquery.column_name_alias.size()) {
-						subquery.column_name_alias[i] = ref.column_name_alias[i];
-					} else {
-						subquery.column_name_alias.push_back(ref.column_name_alias[i]);
-					}
-				}
-				return Bind(subquery, &found_cte.get());
-			} else {
+			if (ctebinding && (cte.query->node->type == QueryNodeType::RECURSIVE_CTE_NODE ||
+			                   cte.materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS)) {
 				// There is a CTE binding in the BindContext.
 				// This can only be the case if there is a recursive CTE,
 				// or a materialized CTE present.
@@ -137,9 +121,42 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 				result->types = ctebinding->types;
 				result->bound_columns = std::move(names);
 				return std::move(result);
+			} else {
+				if (CTEIsAlreadyBound(cte)) {
+					// remember error state
+					circular_cte = true;
+					// retry with next candidate CTE
+					continue;
+				}
+
+				// If we have found a materialized CTE, but no corresponding CTE binding,
+				// something is wrong.
+				if (cte.materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
+					throw BinderException(
+					    "There is a WITH item named \"%s\", but it cannot be referenced from this part of the query.",
+					    ref.table_name);
+				}
+
+				// Move CTE to subquery and bind recursively
+				SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(cte.query->Copy()));
+				subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias;
+				subquery.column_name_alias = cte.aliases;
+				for (idx_t i = 0; i < ref.column_name_alias.size(); i++) {
+					if (i < subquery.column_name_alias.size()) {
+						subquery.column_name_alias[i] = ref.column_name_alias[i];
+					} else {
+						subquery.column_name_alias.push_back(ref.column_name_alias[i]);
+					}
+				}
+				return Bind(subquery, &found_cte.get());
 			}
 		}
 		if (circular_cte) {
+			auto replacement_scan_bind_result = BindWithReplacementScan(context, ref);
+			if (replacement_scan_bind_result) {
+				return replacement_scan_bind_result;
+			}
+
 			throw BinderException(
 			    "Circular reference to CTE \"%s\", There are two possible solutions. \n1. use WITH RECURSIVE to "
 			    "use recursive CTEs. \n2. If "
@@ -169,22 +186,18 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		}
 	}
 	if (!table_or_view) {
-		string table_name = ref.catalog_name;
-		if (!ref.schema_name.empty()) {
-			table_name += (!table_name.empty() ? "." : "") + ref.schema_name;
-		}
-		table_name += (!table_name.empty() ? "." : "") + ref.table_name;
 		// table could not be found: try to bind a replacement scan
 		// Try replacement scan bind
-		auto replacement_scan_bind_result = BindWithReplacementScan(context, table_name, ref);
+		auto replacement_scan_bind_result = BindWithReplacementScan(context, 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);
+		auto full_path = ReplacementScan::GetFullPath(ref.catalog_name, ref.schema_name, ref.table_name);
+		auto extension_loaded = TryLoadExtensionForReplacementScan(context, full_path);
 		if (extension_loaded) {
-			replacement_scan_bind_result = BindWithReplacementScan(context, table_name, ref);
+			replacement_scan_bind_result = BindWithReplacementScan(context, ref);
 			if (replacement_scan_bind_result) {
 				return replacement_scan_bind_result;
 			}
@@ -203,7 +216,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		auto &table = table_or_view->Cast<TableCatalogEntry>();
 
 		auto &properties = GetStatementProperties();
-		properties.read_databases.insert(table.ParentCatalog().GetName());
+		properties.RegisterDBRead(table.ParentCatalog(), context);
 
 		unique_ptr<FunctionData> bind_data;
 		auto scan_function = table.GetScanFunction(context, bind_data);
@@ -225,7 +238,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 
 		auto logical_get = make_uniq<LogicalGet>(table_index, scan_function, std::move(bind_data),
 		                                         std::move(return_types), std::move(return_names));
-		bind_context.AddBaseTable(table_index, alias, table_names, table_types, logical_get->column_ids,
+		bind_context.AddBaseTable(table_index, alias, table_names, table_types, logical_get->GetMutableColumnIds(),
 		                          logical_get->GetTable().get());
 		return make_uniq_base<BoundTableRef, BoundBaseTableRef>(table, std::move(logical_get));
 	}

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

@@ -6,8 +6,9 @@
 namespace duckdb {
 
 unique_ptr<BoundTableRef> Binder::Bind(ColumnDataRef &ref) {
-	auto types = ref.collection->Types();
-	auto result = make_uniq<BoundColumnDataRef>(std::move(ref.collection));
+	auto &collection = *ref.collection;
+	auto types = collection.Types();
+	auto result = make_uniq<BoundColumnDataRef>(collection);
 	result->bind_index = GenerateTableIndex();
 	bind_context.AddGenericBinding(result->bind_index, ref.alias, ref.expected_names, types);
 	return unique_ptr_cast<BoundColumnDataRef, BoundTableRef>(std::move(result));

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

@@ -0,0 +1,16 @@
+#include "duckdb/parser/tableref/delimgetref.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/tableref/bound_delimgetref.hpp"
+
+namespace duckdb {
+
+unique_ptr<BoundTableRef> Binder::Bind(DelimGetRef &ref) {
+	// Have to add bindings
+	idx_t tbl_idx = GenerateTableIndex();
+	string internal_name = "__internal_delim_get_ref_" + std::to_string(tbl_idx);
+	bind_context.AddGenericBinding(tbl_idx, internal_name, ref.internal_aliases, ref.types);
+
+	return make_uniq<BoundDelimGetRef>(tbl_idx, ref.types);
+}
+
+} // namespace duckdb

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

@@ -88,6 +88,8 @@ static void SetPrimaryBinding(UsingColumnSet &set, JoinType join_type, const str
 		set.primary_binding = left_binding;
 		break;
 	case JoinType::RIGHT:
+	case JoinType::RIGHT_SEMI:
+	case JoinType::RIGHT_ANTI:
 		set.primary_binding = right_binding;
 		break;
 	default:
@@ -134,9 +136,26 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 
 	result->type = ref.type;
 	result->left = left_binder.BindJoin(*this, *ref.left);
+	result->delim_flipped = ref.delim_flipped;
+
 	{
 		LateralBinder binder(left_binder, context);
 		result->right = right_binder.BindJoin(*this, *ref.right);
+		if (!ref.duplicate_eliminated_columns.empty()) {
+			if (ref.delim_flipped) {
+				// We gotta use the expression binder of the right side
+				ExpressionBinder expr_binder(right_binder, context);
+				for (auto &col : ref.duplicate_eliminated_columns) {
+					result->duplicate_eliminated_columns.emplace_back(expr_binder.Bind(col));
+				}
+			} else {
+				// We use the left side
+				ExpressionBinder expr_binder(left_binder, context);
+				for (auto &col : ref.duplicate_eliminated_columns) {
+					result->duplicate_eliminated_columns.emplace_back(expr_binder.Bind(col));
+				}
+			}
+		}
 		bool is_lateral = false;
 		// Store the correlated columns in the right binder in bound ref for planning of LATERALs
 		// Ignore the correlated columns in the left binder, flattening handles those correlations
@@ -283,6 +302,7 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 	}
 
 	auto right_bindings_list_copy = right_binder.bind_context.GetBindingsList();
+	auto left_bindings_list_copy = left_binder.bind_context.GetBindingsList();
 
 	bind_context.AddContext(std::move(left_binder.bind_context));
 	bind_context.AddContext(std::move(right_binder.bind_context));
@@ -317,8 +337,18 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		result->condition = binder.Bind(ref.condition);
 	}
 
-	if (result->type == JoinType::SEMI || result->type == JoinType::ANTI) {
+	if (result->type == JoinType::SEMI || result->type == JoinType::ANTI || result->type == JoinType::MARK) {
 		bind_context.RemoveContext(right_bindings_list_copy);
+		if (result->type == JoinType::MARK) {
+			auto mark_join_idx = GenerateTableIndex();
+			string mark_join_alias = "__internal_mark_join_ref" + to_string(mark_join_idx);
+			bind_context.AddGenericBinding(mark_join_idx, mark_join_alias, {"__mark_index_column"},
+			                               {LogicalType::BOOLEAN});
+			result->mark_index = mark_join_idx;
+		}
+	}
+	if (result->type == JoinType::RIGHT_SEMI || result->type == JoinType::RIGHT_ANTI) {
+		bind_context.RemoveContext(left_bindings_list_copy);
 	}
 
 	return std::move(result);

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

@@ -290,6 +290,9 @@ void ExtractPivotAggregates(BoundTableRef &node, vector<unique_ptr<Expression>>
 	}
 	auto &select2 = subq2.subquery->Cast<BoundSelectNode>();
 	for (auto &aggr : select2.aggregates) {
+		if (aggr->alias == "__collated_group") {
+			continue;
+		}
 		aggregates.push_back(aggr->Copy());
 	}
 }
@@ -538,6 +541,9 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 	for (auto &entry : unpivot.entries) {
 		ExtractUnpivotEntries(child_binder, entry, unpivot_entries);
 	}
+	if (unpivot_entries.empty()) {
+		throw BinderException(ref, "UNPIVOT clause must unpivot on at least one column - zero were provided");
+	}
 
 	case_insensitive_set_t handled_columns;
 	case_insensitive_map_t<string> name_map;

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

@@ -61,6 +61,8 @@ unique_ptr<BoundTableRef> Binder::BindShowTable(ShowRef &ref) {
 		sql = PragmaShowDatabases();
 	} else if (lname == "\"tables\"") {
 		sql = PragmaShowTables();
+	} else if (lname == "\"variables\"") {
+		sql = PragmaShowVariables();
 	} else if (lname == "__show_tables_expanded") {
 		sql = PragmaShowTablesExpanded();
 	} else {

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

@@ -23,32 +23,71 @@
 
 namespace duckdb {
 
-static bool IsTableInTableOutFunction(TableFunctionCatalogEntry &table_function) {
-	auto fun = table_function.functions.GetFunctionByOffset(0);
-	return table_function.functions.Size() == 1 && fun.arguments.size() == 1 &&
-	       fun.arguments[0].id() == LogicalTypeId::TABLE;
+enum class TableFunctionBindType { STANDARD_TABLE_FUNCTION, TABLE_IN_OUT_FUNCTION, TABLE_PARAMETER_FUNCTION };
+
+static TableFunctionBindType GetTableFunctionBindType(TableFunctionCatalogEntry &table_function,
+                                                      vector<unique_ptr<ParsedExpression>> &expressions) {
+	// first check if all expressions are scalar
+	// if they are we always bind as a standard table function
+	bool all_scalar = true;
+	for (auto &expr : expressions) {
+		if (!expr->IsScalar()) {
+			all_scalar = false;
+			break;
+		}
+	}
+	if (all_scalar) {
+		return TableFunctionBindType::STANDARD_TABLE_FUNCTION;
+	}
+	// if we have non-scalar parameters - we need to look at the function definition to decide how to bind
+	// if a function does not have an in_out_function defined, we need to bind as a standard table function regardless
+	bool has_in_out_function = false;
+	bool has_standard_table_function = false;
+	bool has_table_parameter = false;
+	for (idx_t function_idx = 0; function_idx < table_function.functions.Size(); function_idx++) {
+		const auto &function = table_function.functions.GetFunctionReferenceByOffset(function_idx);
+		for (auto &arg : function.arguments) {
+			if (arg.id() == LogicalTypeId::TABLE) {
+				has_table_parameter = true;
+			}
+		}
+		if (function.in_out_function) {
+			has_in_out_function = true;
+		} else if (function.function || function.bind_replace) {
+			has_standard_table_function = true;
+		} else {
+			throw InternalException("Function \"%s\" has neither in_out_function nor function defined",
+			                        table_function.name);
+		}
+	}
+	if (has_table_parameter) {
+		if (table_function.functions.Size() != 1) {
+			throw InternalException(
+			    "Function \"%s\" has a TABLE parameter, and multiple function overloads - this is not supported",
+			    table_function.name);
+		}
+		return TableFunctionBindType::TABLE_PARAMETER_FUNCTION;
+	}
+	if (has_in_out_function && has_standard_table_function) {
+		throw InternalException("Function \"%s\" is both an in_out_function and a table function", table_function.name);
+	}
+	return has_in_out_function ? TableFunctionBindType::TABLE_IN_OUT_FUNCTION
+	                           : TableFunctionBindType::STANDARD_TABLE_FUNCTION;
 }
 
-bool Binder::BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &expressions,
-                                         unique_ptr<BoundSubqueryRef> &subquery, ErrorData &error) {
+void Binder::BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &expressions,
+                                         unique_ptr<BoundSubqueryRef> &subquery) {
 	auto binder = Binder::CreateBinder(this->context, this);
 	unique_ptr<QueryNode> subquery_node;
-	if (expressions.size() == 1 && expressions[0]->type == ExpressionType::SUBQUERY) {
-		// general case: argument is a subquery, bind it as part of the node
-		auto &se = expressions[0]->Cast<SubqueryExpression>();
-		subquery_node = std::move(se.subquery->node);
-	} else {
-		// special case: non-subquery parameter to table-in table-out function
-		// generate a subquery and bind that (i.e. UNNEST([1,2,3]) becomes UNNEST((SELECT [1,2,3]))
-		auto select_node = make_uniq<SelectNode>();
-		select_node->select_list = std::move(expressions);
-		select_node->from_table = make_uniq<EmptyTableRef>();
-		subquery_node = std::move(select_node);
-	}
+	// generate a subquery and bind that (i.e. UNNEST([1,2,3]) becomes UNNEST((SELECT [1,2,3]))
+	auto select_node = make_uniq<SelectNode>();
+	select_node->select_list = std::move(expressions);
+	select_node->from_table = make_uniq<EmptyTableRef>();
+	subquery_node = std::move(select_node);
+	binder->can_contain_nulls = true;
 	auto node = binder->BindNode(*subquery_node);
 	subquery = make_uniq<BoundSubqueryRef>(std::move(binder), std::move(node));
 	MoveCorrelatedExpressions(*subquery->binder);
-	return true;
 }
 
 bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_function,
@@ -56,10 +95,13 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
                                          vector<LogicalType> &arguments, vector<Value> &parameters,
                                          named_parameter_map_t &named_parameters,
                                          unique_ptr<BoundSubqueryRef> &subquery, ErrorData &error) {
-	if (IsTableInTableOutFunction(table_function)) {
-		// special case binding for table-in table-out function
-		arguments.emplace_back(LogicalTypeId::TABLE);
-		return BindTableInTableOutFunction(expressions, subquery, error);
+	auto bind_type = GetTableFunctionBindType(table_function, expressions);
+	if (bind_type == TableFunctionBindType::TABLE_IN_OUT_FUNCTION) {
+		// bind table in-out function
+		BindTableInTableOutFunction(expressions, subquery);
+		// fetch the arguments from the subquery
+		arguments = subquery->subquery->types;
+		return true;
 	}
 	bool seen_subquery = false;
 	for (auto &child : expressions) {
@@ -76,8 +118,12 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 					child = std::move(comp.right);
 				}
 			}
+		} else if (!child->alias.empty()) {
+			// <name> => <expression> will set the alias of <expression> to <name>
+			parameter_name = child->alias;
 		}
-		if (child->type == ExpressionType::SUBQUERY) {
+		if (bind_type == TableFunctionBindType::TABLE_PARAMETER_FUNCTION && child->type == ExpressionType::SUBQUERY) {
+			D_ASSERT(table_function.functions.Size() == 1);
 			auto fun = table_function.functions.GetFunctionByOffset(0);
 			if (table_function.functions.Size() != 1 || fun.arguments.empty() ||
 			    fun.arguments[0].id() != LogicalTypeId::TABLE) {
@@ -85,20 +131,19 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 				    "Only table-in-out functions can have subquery parameters - %s only accepts constant parameters",
 				    fun.name);
 			}
-			// this separate subquery binding path is only used by python_map
-			// FIXME: this should be unified with `BindTableInTableOutFunction` above
 			if (seen_subquery) {
 				error = ErrorData("Table function can have at most one subquery parameter");
 				return false;
 			}
 			auto binder = Binder::CreateBinder(this->context, this);
+			binder->can_contain_nulls = true;
 			auto &se = child->Cast<SubqueryExpression>();
 			auto node = binder->BindNode(*se.subquery->node);
 			subquery = make_uniq<BoundSubqueryRef>(std::move(binder), std::move(node));
+			MoveCorrelatedExpressions(*subquery->binder);
 			seen_subquery = true;
 			arguments.emplace_back(LogicalTypeId::TABLE);
-			parameters.emplace_back(
-			    Value(LogicalType::INVALID)); // this is a dummy value so the lengths of arguments and parameter match
+			parameters.emplace_back(Value());
 			continue;
 		}
 
@@ -192,13 +237,12 @@ unique_ptr<LogicalOperator> Binder::BindTableFunctionInternal(TableFunction &tab
 	get->input_table_types = input_table_types;
 	get->input_table_names = input_table_names;
 	if (table_function.in_out_function && !table_function.projection_pushdown) {
-		get->column_ids.reserve(return_types.size());
 		for (idx_t i = 0; i < return_types.size(); i++) {
-			get->column_ids.push_back(i);
+			get->AddColumnId(i);
 		}
 	}
 	// now add the table function to the bind context so its columns can be bound
-	bind_context.AddTableFunction(bind_index, function_name, return_names, return_types, get->column_ids,
+	bind_context.AddTableFunction(bind_index, function_name, return_names, return_types, get->GetMutableColumnIds(),
 	                              get->GetTable().get());
 	return std::move(get);
 }
@@ -273,30 +317,46 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	// now check the named parameters
 	BindNamedParameters(table_function.named_parameters, named_parameters, error_context, table_function.name);
 
-	// cast the parameters to the type of the function
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		auto target_type = i < table_function.arguments.size() ? table_function.arguments[i] : table_function.varargs;
-
-		if (target_type != LogicalType::ANY && target_type != LogicalType::TABLE &&
-		    target_type != LogicalType::POINTER && target_type.id() != LogicalTypeId::LIST) {
-			parameters[i] = parameters[i].CastAs(context, target_type);
-		}
-	}
-
 	vector<LogicalType> input_table_types;
 	vector<string> input_table_names;
 
 	if (subquery) {
 		input_table_types = subquery->subquery->types;
 		input_table_names = subquery->subquery->names;
+	} else if (table_function.in_out_function) {
+		for (auto &param : parameters) {
+			input_table_types.push_back(param.type());
+			input_table_names.push_back(string());
+		}
 	}
-	auto get = BindTableFunctionInternal(table_function, ref, std::move(parameters), std::move(named_parameters),
-	                                     std::move(input_table_types), std::move(input_table_names));
-	if (subquery) {
-		get->children.push_back(Binder::CreatePlan(*subquery));
+	if (!parameters.empty()) {
+		// cast the parameters to the type of the function
+		for (idx_t i = 0; i < arguments.size(); i++) {
+			auto target_type =
+			    i < table_function.arguments.size() ? table_function.arguments[i] : table_function.varargs;
+
+			if (target_type != LogicalType::ANY && target_type != LogicalType::POINTER &&
+			    target_type.id() != LogicalTypeId::LIST && target_type != LogicalType::TABLE) {
+				parameters[i] = parameters[i].CastAs(context, target_type);
+			}
+		}
+	} else if (subquery) {
+		for (idx_t i = 0; i < arguments.size(); i++) {
+			auto target_type =
+			    i < table_function.arguments.size() ? table_function.arguments[i] : table_function.varargs;
+
+			if (target_type != LogicalType::ANY && target_type != LogicalType::POINTER &&
+			    target_type.id() != LogicalTypeId::LIST) {
+				input_table_types[i] = target_type;
+			}
+		}
 	}
 
-	return make_uniq_base<BoundTableRef, BoundTableFunction>(std::move(get));
+	auto get = BindTableFunctionInternal(table_function, ref, std::move(parameters), std::move(named_parameters),
+	                                     std::move(input_table_types), std::move(input_table_names));
+	auto table_function_ref = make_uniq<BoundTableFunction>(std::move(get));
+	table_function_ref->subquery = std::move(subquery);
+	return std::move(table_function_ref);
 }
 
 } // namespace duckdb

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

@@ -0,0 +1,11 @@
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/tableref/bound_basetableref.hpp"
+#include "duckdb/planner/operator/logical_delim_get.hpp"
+namespace duckdb {
+
+unique_ptr<LogicalOperator> Binder::CreatePlan(BoundDelimGetRef &ref) {
+	return make_uniq<LogicalDelimGet>(ref.bind_index, ref.column_types);
+}
+
+} // namespace duckdb

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

@@ -76,7 +76,9 @@ void LogicalComparisonJoin::ExtractJoinConditions(
 		auto total_side = JoinSide::GetJoinSide(*expr, left_bindings, right_bindings);
 		if (total_side != JoinSide::BOTH) {
 			// join condition does not reference both sides, add it as filter under the join
-			if (type == JoinType::LEFT && total_side == JoinSide::RIGHT) {
+			// BUT don't push right side filters into AsOf because it is really a table lookup
+			// and we shouldn't remove anything from the table.
+			if (type == JoinType::LEFT && total_side == JoinSide::RIGHT && ref_type != JoinRefType::ASOF) {
 				// filter is on RHS and the join is a LEFT OUTER join, we can push it in the right child
 				if (right_child->type != LogicalOperatorType::LOGICAL_FILTER) {
 					// not a filter yet, push a new empty filter
@@ -342,13 +344,16 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	// now create the join operator from the join condition
 	auto result = LogicalComparisonJoin::CreateJoin(context, ref.type, ref.ref_type, std::move(left), std::move(right),
 	                                                std::move(ref.condition));
-
 	optional_ptr<LogicalOperator> join;
 	if (result->type == LogicalOperatorType::LOGICAL_FILTER) {
 		join = result->children[0].get();
 	} else {
 		join = result.get();
 	}
+
+	if (ref.type == JoinType::MARK) {
+		join->Cast<LogicalJoin>().mark_index = ref.mark_index;
+	}
 	for (auto &child : join->children) {
 		if (child->type == LogicalOperatorType::LOGICAL_FILTER) {
 			auto &filter = child->Cast<LogicalFilter>();
@@ -383,6 +388,14 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	default:
 		break;
 	}
+	if (!ref.duplicate_eliminated_columns.empty()) {
+		auto &comp_join = join->Cast<LogicalComparisonJoin>();
+		comp_join.type = LogicalOperatorType::LOGICAL_DELIM_JOIN;
+		comp_join.delim_flipped = ref.delim_flipped;
+		for (auto &col : ref.duplicate_eliminated_columns) {
+			comp_join.duplicate_eliminated_columns.emplace_back(col->Copy());
+		}
+	}
 	return result;
 }
 

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

@@ -4,6 +4,10 @@
 namespace duckdb {
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
+	if (ref.subquery) {
+		auto child_node = CreatePlan(*ref.subquery);
+		ref.get->children.push_back(std::move(child_node));
+	}
 	return std::move(ref.get);
 }